Subversion Repositories Kolibri OS

Rev

Rev 448 | Rev 546 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. $Revision: 465 $
  2. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  3. ;;                                                              ;;
  4. ;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
  5. ;; Distributed under terms of the GNU General Public License    ;;
  6. ;;                                                              ;;
  7. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  8.  
  9. struc MEM_BLOCK
  10. {  .next_block  dd ?
  11.    .prev_block  dd ? ;+4
  12.    .list_fd     dd ? ;+8
  13.    .list_bk     dd ? ;+12
  14.    .base        dd ? ;+16
  15.    .size        dd ? ;+20
  16.    .flags       dd ? ;+24
  17.    .handle      dd ? ;+28
  18. }
  19.  
  20. MEM_LIST_OFFSET equ  8
  21. FREE_BLOCK     equ  4
  22. USED_BLOCK     equ  8
  23.  
  24. virtual at 0
  25.   MEM_BLOCK MEM_BLOCK
  26. end virtual
  27.  
  28. MEM_BLOCK_SIZE equ 8*4
  29.  
  30. block_next   equ MEM_BLOCK.next_block
  31. block_prev   equ MEM_BLOCK.prev_block
  32. list_fd     equ MEM_BLOCK.list_fd
  33. list_bk     equ MEM_BLOCK.list_bk
  34. block_base   equ MEM_BLOCK.base
  35. block_size   equ MEM_BLOCK.size
  36. block_flags equ MEM_BLOCK.flags
  37.  
  38. macro calc_index op
  39. {          shr op, 12
  40.            dec op
  41.            cmp op, 63
  42.            jna @f
  43.            mov op, 63
  44. @@:
  45. }
  46.  
  47. macro remove_from_list op
  48. {          mov edx, [op+list_fd]
  49.            mov ecx, [op+list_bk]
  50.            test edx, edx
  51.            jz @f
  52.            mov [edx+list_bk], ecx
  53. @@:
  54.            test ecx, ecx
  55.            jz @f
  56.            mov [ecx+list_fd], edx
  57. @@:
  58.            mov [op+list_fd],0
  59.            mov [op+list_bk],0
  60. }
  61.  
  62. macro remove_from_free op
  63. {
  64.            remove_from_list op
  65.  
  66.            mov eax, [op+block_size]
  67.            calc_index eax
  68.            cmp [mem_block_list+eax*4], op
  69.            jne @f
  70.            mov [mem_block_list+eax*4], edx
  71. @@:
  72.            cmp [mem_block_list+eax*4], 0
  73.            jne @f
  74.            btr [mem_block_mask], eax
  75. @@:
  76. }
  77.  
  78. macro remove_from_used op
  79. {
  80.            mov edx, [op+list_fd]
  81.            mov ecx, [op+list_bk]
  82.            mov [edx+list_bk], ecx
  83.            mov [ecx+list_fd], edx
  84.            mov [op+list_fd], 0
  85.            mov [op+list_bk], 0
  86. }
  87.  
  88. align 4
  89. proc init_kernel_heap
  90.  
  91.            mov ecx, 64/4
  92.            mov edi, mem_block_list
  93.            xor eax, eax
  94.            cld
  95.            rep stosd
  96.  
  97.            mov ecx, 512/4
  98.            mov edi, mem_block_map
  99.            not eax
  100.            rep stosd
  101.  
  102.            mov [mem_block_start], mem_block_map
  103.            mov [mem_block_end], mem_block_map+512
  104.            mov [mem_block_arr], HEAP_BASE
  105.  
  106.            mov eax, mem_used.fd-MEM_LIST_OFFSET
  107.            mov [mem_used.fd], eax
  108.            mov [mem_used.bk], eax
  109.  
  110.            stdcall alloc_pages, dword 32
  111.            mov ecx, 32
  112.            mov edx, eax
  113.            mov edi, HEAP_BASE
  114. .l1:
  115.            stdcall map_page,edi,edx,PG_SW
  116.            add edi, 0x1000
  117.            add edx, 0x1000
  118.            dec ecx
  119.            jnz .l1
  120.  
  121.            mov edi, HEAP_BASE
  122.            mov ebx, HEAP_BASE+MEM_BLOCK_SIZE
  123.            xor eax, eax
  124.            mov [edi+block_next], ebx
  125.            mov [edi+block_prev], eax
  126.            mov [edi+list_fd], eax
  127.            mov [edi+list_bk], eax
  128.            mov [edi+block_base], HEAP_BASE
  129.            mov [edi+block_size], 4096*MEM_BLOCK_SIZE
  130.            mov [edi+block_flags], USED_BLOCK
  131.  
  132.            mov [ebx+block_next], eax
  133.            mov [ebx+block_prev], eax
  134.            mov [ebx+list_fd], eax
  135.            mov [ebx+list_bk], eax
  136.            mov [ebx+block_base], HEAP_BASE+4096*MEM_BLOCK_SIZE
  137.  
  138.            mov ecx, [MEM_AMOUNT]
  139.            sub ecx, HEAP_BASE + 4096*MEM_BLOCK_SIZE
  140.            mov [heap_size], ecx
  141.            mov [heap_free], ecx
  142.            mov [ebx+block_size], ecx
  143.            mov [ebx+block_flags], FREE_BLOCK
  144.  
  145.            mov [mem_block_mask], eax
  146.            mov [mem_block_mask+4],0x80000000
  147.  
  148.            mov [mem_block_list+63*4], ebx
  149.            mov byte [mem_block_map], 0xFC
  150.            and [heap_mutex], 0
  151.            mov [heap_blocks], 4095
  152.            mov [free_blocks], 4095
  153.            ret
  154. endp
  155.  
  156. ; param
  157. ;  eax= required size
  158. ;
  159. ; retval
  160. ;  edi= memory block descriptor
  161. ;  ebx= descriptor index
  162.  
  163. align 4
  164. get_block:
  165.            mov ecx, eax
  166.            shr ecx, 12
  167.            dec ecx
  168.            cmp ecx, 63
  169.            jle .get_index
  170.            mov ecx, 63
  171. .get_index:
  172.            lea esi, [mem_block_mask]
  173.            xor ebx, ebx
  174.            or edx, -1
  175.  
  176.            cmp ecx, 32
  177.            jb .bit_test
  178.  
  179.            sub ecx, 32
  180.            add ebx, 32
  181.            add esi, 4
  182. .bit_test:
  183.            shl edx, cl
  184.            and edx, [esi]
  185. .find:
  186.            bsf edi, edx
  187.            jz .high_mask
  188.            add ebx, edi
  189.            mov edi, [mem_block_list+ebx*4]
  190. .check_size:
  191.            cmp eax, [edi+block_size]
  192.            ja .next
  193.            ret
  194.  
  195. .high_mask:
  196.            add esi, 4
  197.            cmp esi, mem_block_mask+8
  198.            jae .err
  199.            add ebx, 32
  200.            mov edx, [esi]
  201.            jmp .find
  202. .next:
  203.            mov edi, [edi+list_fd]
  204.            test edi, edi
  205.            jnz .check_size
  206. .err:
  207.            xor edi, edi
  208.            ret
  209.  
  210. align 4
  211. proc alloc_mem_block
  212.  
  213.            mov ebx, [mem_block_start]
  214.            mov ecx, [mem_block_end]
  215. .l1:
  216.            bsf eax,[ebx];
  217.            jnz found
  218.            add ebx,4
  219.            cmp ebx, ecx
  220.            jb .l1
  221.            xor eax,eax
  222.            ret
  223.  
  224. found:
  225.            btr [ebx], eax
  226.            mov [mem_block_start],ebx
  227.            sub ebx, mem_block_map
  228.            lea eax,[eax+ebx*8]
  229.            shl eax, 5
  230.            add eax, [mem_block_arr]
  231.            dec [free_blocks]
  232.            ret
  233. endp
  234.  
  235. proc free_mem_block
  236.            mov dword [eax], 0
  237.            mov dword [eax+4], 0
  238.            mov dword [eax+8], 0
  239.            mov dword [eax+12], 0
  240.            mov dword [eax+16], 0
  241. ;           mov dword [eax+20], 0
  242.            mov dword [eax+24], 0
  243.            mov dword [eax+28], 0
  244.  
  245.            sub eax, [mem_block_arr]
  246.            shr eax, 5
  247.  
  248.            mov ebx, mem_block_map
  249.            bts [ebx], eax
  250.            inc [free_blocks]
  251.            shr eax, 3
  252.            and eax, not 3
  253.            add eax, ebx
  254.            cmp [mem_block_start], eax
  255.            ja @f
  256.            ret
  257. @@:
  258.            mov [mem_block_start], eax
  259.            ret
  260. .err:
  261.            xor eax, eax
  262.            ret
  263. endp
  264.  
  265. align 4
  266. proc alloc_kernel_space stdcall, size:dword
  267.            local block_ind:DWORD
  268.  
  269.            mov eax, [size]
  270.            add eax, 4095
  271.            and eax, not 4095
  272.            mov [size], eax
  273.  
  274.            mov ebx, heap_mutex
  275.            call wait_mutex    ;ebx
  276.  
  277.            cmp eax, [heap_free]
  278.            ja .error
  279.  
  280.            call get_block ; eax
  281.            test edi, edi
  282.            jz .error
  283.  
  284.            cmp [edi+block_flags], FREE_BLOCK
  285.            jne .error
  286.  
  287.            mov [block_ind], ebx   ;index of allocated block
  288.  
  289.            mov eax, [edi+block_size]
  290.            cmp eax, [size]
  291.            je .m_eq_size
  292.  
  293.            call alloc_mem_block
  294.            and eax, eax
  295.            jz .error
  296.  
  297.            mov esi, eax           ;esi - splitted block
  298.  
  299.            mov [esi+block_next], edi
  300.            mov eax, [edi+block_prev]
  301.            mov [esi+block_prev], eax
  302.            mov [edi+block_prev], esi
  303.            mov [esi+list_fd], 0
  304.            mov [esi+list_bk], 0
  305.            and eax, eax
  306.            jz @f
  307.            mov [eax+block_next], esi
  308. @@:
  309.            mov ebx, [edi+block_base]
  310.            mov [esi+block_base], ebx
  311.            mov edx, [size]
  312.            mov [esi+block_size], edx
  313.            add [edi+block_base], edx
  314.            sub [edi+block_size], edx
  315.  
  316.            mov eax, [edi+block_size]
  317.            shr eax, 12
  318.            sub eax, 1
  319.            cmp eax, 63
  320.            jna @f
  321.            mov eax, 63
  322. @@:
  323.            cmp eax, [block_ind]
  324.            je .m_eq_ind
  325.  
  326.            remove_from_list edi
  327.  
  328.            mov ecx, [block_ind]
  329.            mov [mem_block_list+ecx*4], edx
  330.  
  331.            test edx, edx
  332.            jnz @f
  333.            btr [mem_block_mask], ecx
  334. @@:
  335.            mov edx, [mem_block_list+eax*4]
  336.            mov [edi+list_fd], edx
  337.            test edx, edx
  338.            jz @f
  339.            mov [edx+list_bk], edi
  340. @@:
  341.            mov [mem_block_list+eax*4], edi
  342.            bts [mem_block_mask], eax
  343. .m_eq_ind:
  344.            mov ecx, mem_used.fd-MEM_LIST_OFFSET
  345.            mov edx, [ecx+list_fd]
  346.            mov [esi+list_fd], edx
  347.            mov [esi+list_bk], ecx
  348.            mov [ecx+list_fd], esi
  349.            mov [edx+list_bk], esi
  350.  
  351.            mov [esi+block_flags], USED_BLOCK
  352.            mov eax, [esi+block_base]
  353.            mov ebx, [size]
  354.            sub [heap_free], ebx
  355.            and [heap_mutex], 0
  356.            ret
  357. .m_eq_size:
  358.            remove_from_list edi
  359.            mov [mem_block_list+ebx*4], edx
  360.            and edx, edx
  361.            jnz @f
  362.            btr [mem_block_mask], ebx
  363. @@:
  364.            mov ecx, mem_used.fd-MEM_LIST_OFFSET
  365.            mov edx, [ecx+list_fd]
  366.            mov [edi+list_fd], edx
  367.            mov [edi+list_bk], ecx
  368.            mov [ecx+list_fd], edi
  369.            mov [edx+list_bk], edi
  370.  
  371.            mov [edi+block_flags], USED_BLOCK
  372.            mov eax, [edi+block_base]
  373.            mov ebx, [size]
  374.            sub [heap_free], ebx
  375.            and [heap_mutex], 0
  376.            ret
  377. .error:
  378.            xor eax, eax
  379.            mov [heap_mutex], eax
  380.            ret
  381. endp
  382.  
  383. align 4
  384. proc free_kernel_space stdcall uses ebx ecx edx esi edi, base:dword
  385.  
  386.            mov ebx, heap_mutex
  387.            call wait_mutex    ;ebx
  388.  
  389.            mov eax, [base]
  390.            mov esi, [mem_used.fd]
  391. @@:
  392.            cmp esi, mem_used.fd-MEM_LIST_OFFSET
  393.            je .fail
  394.  
  395.            cmp [esi+block_base], eax
  396.            je .found
  397.            mov esi, [esi+list_fd]
  398.            jmp @b
  399. .found:
  400.            cmp [esi+block_flags], USED_BLOCK
  401.            jne .fail
  402.  
  403.            mov eax, [esi+block_size]
  404.            add [heap_free], eax
  405.  
  406.            mov edi, [esi+block_next]
  407.            test edi, edi
  408.            jz .prev
  409.  
  410.            cmp [edi+block_flags], FREE_BLOCK
  411.            jne .prev
  412.  
  413.            remove_from_free edi
  414.  
  415.            mov edx, [edi+block_next]
  416.            mov [esi+block_next], edx
  417.            test edx, edx
  418.            jz @f
  419.  
  420.            mov [edx+block_prev], esi
  421. @@:
  422.            mov ecx, [edi+block_size]
  423.            add [esi+block_size], ecx
  424.  
  425.            mov eax, edi
  426.            call free_mem_block
  427. .prev:
  428.            mov edi, [esi+block_prev]
  429.            test edi, edi
  430.            jz .insert
  431.  
  432.            cmp [edi+block_flags], FREE_BLOCK
  433.            jne .insert
  434.  
  435.            remove_from_used esi
  436.  
  437.            mov edx, [esi+block_next]
  438.            mov [edi+block_next], edx
  439.            test edx, edx
  440.            jz @f
  441.            mov [edx+block_prev], edi
  442. @@:
  443.            mov eax, esi
  444.            call free_mem_block
  445.  
  446.            mov ecx, [edi+block_size]
  447.            mov eax, [esi+block_size]
  448.            add eax, ecx
  449.            mov [edi+block_size], eax
  450.  
  451.            calc_index eax
  452.            calc_index ecx
  453.            cmp eax, ecx
  454.            je .m_eq
  455.  
  456.            push ecx
  457.            remove_from_list edi
  458.            pop ecx
  459.  
  460.            cmp [mem_block_list+ecx*4], edi
  461.            jne @f
  462.            mov [mem_block_list+ecx*4], edx
  463. @@:
  464.            cmp [mem_block_list+ecx*4], 0
  465.            jne @f
  466.            btr [mem_block_mask], ecx
  467. @@:
  468.            mov esi, [mem_block_list+eax*4]
  469.            mov [mem_block_list+eax*4], edi
  470.            mov [edi+list_fd], esi
  471.            test esi, esi
  472.            jz @f
  473.            mov [esi+list_bk], edi
  474. @@:
  475.            bts [mem_block_mask], eax
  476. .m_eq:
  477.            xor eax, eax
  478.            mov [heap_mutex], eax
  479.            dec eax
  480.            ret
  481. .insert:
  482.            remove_from_used esi
  483.  
  484.            mov eax, [esi+block_size]
  485.            calc_index eax
  486.  
  487.            mov edi, [mem_block_list+eax*4]
  488.            mov [mem_block_list+eax*4], esi
  489.            mov [esi+list_fd], edi
  490.            test edi, edi
  491.            jz @f
  492.            mov [edi+list_bk], esi
  493. @@:
  494.            bts [mem_block_mask], eax
  495.            mov [esi+block_flags],FREE_BLOCK
  496.            xor eax, eax
  497.            mov [heap_mutex], eax
  498.            dec eax
  499.            ret
  500. .fail:
  501.            xor eax, eax
  502.            mov [heap_mutex], eax
  503.            ret
  504. endp
  505.  
  506. align 4
  507. proc kernel_alloc stdcall, size:dword
  508.            locals
  509.              lin_addr    dd ?
  510.              pages_count dd ?
  511.            endl
  512.  
  513.            mov eax, [size]
  514.            add eax, 4095
  515.            and eax, not 4095;
  516.            mov [size], eax
  517.            and eax, eax
  518.            jz .err
  519.            mov ebx, eax
  520.            shr ebx, 12
  521.            mov [pages_count], ebx
  522.  
  523.            stdcall alloc_kernel_space, eax
  524.            test eax, eax
  525.            jz .err
  526.            mov [lin_addr], eax
  527.  
  528.            mov ecx, [pages_count]
  529.            mov edx, eax
  530.            mov ebx, ecx
  531.  
  532.            shr ecx, 3
  533.            jz .next
  534.  
  535.            and ebx, not 7
  536.            push ebx
  537.            stdcall alloc_pages, ebx
  538.            pop ecx                   ; yes ecx!!!
  539.            and eax, eax
  540.            jz .err
  541.  
  542.            mov edi, eax
  543.            mov edx, [lin_addr]
  544. @@:
  545.            stdcall map_page,edx,edi,dword PG_SW
  546.            add edx, 0x1000
  547.            add edi, 0x1000
  548.            dec ecx
  549.            jnz @B
  550. .next:
  551.            mov ecx, [pages_count]
  552.            and ecx, 7
  553.            jz .end
  554. @@:
  555.            push ecx
  556.            call alloc_page
  557.            pop ecx
  558.            test eax, eax
  559.            jz .err
  560.  
  561.            stdcall map_page,edx,eax,dword PG_SW
  562.            add edx, 0x1000
  563.            dec ecx
  564.            jnz @B
  565. .end:
  566.            mov eax, [lin_addr]
  567.            ret
  568. .err:
  569.            xor eax, eax
  570.            ret
  571. endp
  572.  
  573. align 4
  574. proc kernel_free stdcall, base:dword
  575.            push ebx esi
  576.  
  577.            mov ebx, heap_mutex
  578.            call wait_mutex    ;ebx
  579.  
  580.            mov eax, [base]
  581.            mov esi, [mem_used.fd]
  582. @@:
  583.            cmp esi, mem_used.fd-MEM_LIST_OFFSET
  584.            je .fail
  585.  
  586.            cmp [esi+block_base], eax
  587.            je .found
  588.            mov esi, [esi+list_fd]
  589.            jmp @b
  590. .found:
  591.            cmp [esi+block_flags], USED_BLOCK
  592.            jne .fail
  593.  
  594.            and [heap_mutex], 0
  595.  
  596.            push ecx
  597.            mov ecx, [esi+block_size];
  598.            shr ecx, 12
  599.            call release_pages   ;eax, ecx
  600.            pop ecx
  601.            stdcall free_kernel_space, [base]
  602.            pop esi ebx
  603.            ret
  604. .fail:
  605.            and [heap_mutex], 0
  606.            pop esi ebx
  607.            ret
  608. endp
  609.  
  610. restore block_next
  611. restore block_prev
  612. restore block_list
  613. restore block_base
  614. restore block_size
  615. restore block_flags
  616.  
  617. ;;;;;;;;;;;;;;      USER     ;;;;;;;;;;;;;;;;;
  618.  
  619. HEAP_TOP equ 0x5FC00000
  620.  
  621. align 4
  622. proc init_heap
  623.  
  624.            mov ebx,[current_slot]
  625.            mov eax, [ebx+APPDATA.heap_top]
  626.            test eax, eax
  627.            jz @F
  628.            sub eax,[ebx+APPDATA.heap_base]
  629.            sub eax, 4096
  630.            ret
  631. @@:
  632.            mov esi, [ebx+APPDATA.mem_size]
  633.            add esi, 4095
  634.            and esi, not 4095
  635.            mov [ebx+APPDATA.mem_size], esi
  636.            mov eax, HEAP_TOP
  637.            mov [ebx+APPDATA.heap_base], esi
  638.            mov [ebx+APPDATA.heap_top], eax
  639.  
  640.            sub eax, esi
  641.        ;    add esi, new_app_base
  642.            shr esi, 10
  643.            mov ecx, eax
  644.            sub eax, 4096
  645.            or ecx, FREE_BLOCK
  646.            mov [page_tabs+esi], ecx
  647.            ret
  648. .exit:
  649.            xor eax, eax
  650.            ret
  651. endp
  652.  
  653. align 4
  654. proc user_alloc stdcall, alloc_size:dword
  655.  
  656.            mov ecx, [alloc_size]
  657.            add ecx, (4095+4096)
  658.            and ecx, not 4095
  659.  
  660.            mov ebx, [current_slot]
  661.            mov esi, dword [ebx+APPDATA.heap_base]  ; heap_base
  662.            mov edi, dword [ebx+APPDATA.heap_top]   ; heap_top
  663. l_0:
  664.            cmp esi, edi
  665.            jae m_exit
  666.  
  667.            mov ebx, esi
  668.            shr ebx, 12
  669.            mov eax, [page_tabs+ebx*4]
  670.            test eax, FREE_BLOCK
  671.            jz test_used
  672.            and eax, 0xFFFFF000
  673.            cmp eax, ecx    ;alloc_size
  674.            jb  m_next
  675.            jz  @f
  676.  
  677.            mov edx, esi
  678.            add edx, ecx
  679.            sub eax, ecx;
  680.            or eax, FREE_BLOCK
  681.            shr edx, 12
  682.            mov [page_tabs+edx*4], eax
  683. @@:
  684.            or ecx, USED_BLOCK
  685.            mov [page_tabs+ebx*4], ecx
  686.            shr ecx, 12
  687.            dec ecx
  688.            inc ebx
  689. @@:
  690.            mov dword [page_tabs+ebx*4], 2
  691.            inc ebx
  692.            dec ecx
  693.            jnz @B
  694.  
  695.            mov     edx, [current_slot]
  696.            mov     ebx, [alloc_size]
  697.            add     ebx, 0xFFF
  698.            and     ebx, not 0xFFF
  699.            add     ebx, [edx+APPDATA.mem_size]
  700.            call    update_mem_size
  701.  
  702.            mov eax, esi
  703.            add eax, 4096
  704.            ret
  705. m_next:
  706.            add esi, eax
  707.            jmp l_0
  708. test_used:
  709.            test eax, USED_BLOCK
  710.            jz m_exit
  711.  
  712.            and eax, 0xFFFFF000
  713.            add esi, eax
  714.            jmp l_0
  715. m_exit:
  716.            xor eax, eax
  717.            ret
  718. endp
  719.  
  720. align 4
  721. proc user_free stdcall, base:dword
  722.  
  723.            mov esi, [base]
  724.            test esi, esi
  725.            jz .exit
  726.  
  727.            xor ebx, ebx
  728.            sub esi, 4096
  729.            shr esi, 12
  730.            mov eax, [page_tabs+esi*4]
  731.            test eax, USED_BLOCK
  732.            jz .not_used
  733.  
  734.            and eax, not 4095
  735.            mov ecx, eax
  736.            or eax, FREE_BLOCK
  737.            mov [page_tabs+esi*4], eax
  738.            inc esi
  739.            sub ecx, 4096
  740.            shr ecx, 12
  741.            mov ebx, ecx
  742. .release:
  743.            xor eax, eax
  744.            xchg eax, [page_tabs+esi*4]
  745.            test eax, 1
  746.            jz @F
  747.            call free_page
  748.            mov eax, esi
  749.            shl eax, 12
  750.            invlpg [eax]
  751. @@:
  752.            inc esi
  753.            dec ecx
  754.            jnz .release
  755. .not_used:
  756.            mov edx, [current_slot]
  757.            mov esi, dword [edx+APPDATA.heap_base]
  758.            mov edi, dword [edx+APPDATA.heap_top]
  759.            sub ebx, [edx+APPDATA.mem_size]
  760.            neg ebx
  761.            call update_mem_size
  762.            call user_normalize
  763.            ret
  764. .exit:
  765.            xor eax, eax
  766.            inc eax
  767.            ret
  768. endp
  769.  
  770. user_normalize:
  771. ; in: esi=heap_base, edi=heap_top
  772. ; out: eax=0 <=> OK
  773. ; destroys: ebx,edx,esi,edi
  774.            shr esi, 12
  775.            shr edi, 12
  776. @@:
  777.            mov eax, [page_tabs+esi*4]
  778.            test eax, USED_BLOCK
  779.            jz .test_free
  780.            shr eax, 12
  781.            add esi, eax
  782.            jmp @B
  783. .test_free:
  784.            test eax, FREE_BLOCK
  785.            jz .err
  786.            mov edx, eax
  787.            shr edx, 12
  788.            add edx, esi
  789.            cmp edx, edi
  790.            jae .exit
  791.  
  792.            mov ebx, [page_tabs+edx*4]
  793.            test ebx, USED_BLOCK
  794.            jz .next_free
  795.  
  796.            shr ebx, 12
  797.            add edx, ebx
  798.            mov esi, edx
  799.            jmp @B
  800. .next_free:
  801.            test ebx, FREE_BLOCK
  802.            jz .err
  803.            and dword [page_tabs+edx*4], 0
  804.            add eax, ebx
  805.            and eax, not 4095
  806.            or eax, FREE_BLOCK
  807.            mov [page_tabs+esi*4], eax
  808.            jmp @B
  809. .exit:
  810.            xor eax, eax
  811.            inc eax
  812.            ret
  813. .err:
  814.            xor eax, eax
  815.            ret
  816.  
  817. user_realloc:
  818. ; in: eax = pointer, ebx = new size
  819. ; out: eax = new pointer or NULL
  820.         test    eax, eax
  821.         jnz     @f
  822. ; realloc(NULL,sz) - same as malloc(sz)
  823.         push    ebx
  824.         call    user_alloc
  825.         ret
  826. @@:
  827.         push    ecx edx
  828.         lea     ecx, [eax - 0x1000]
  829.         shr     ecx, 12
  830.         mov     edx, [page_tabs+ecx*4]
  831.         test    edx, USED_BLOCK
  832.         jnz     @f
  833. ; attempt to realloc invalid pointer
  834. .ret0:
  835.         pop     edx ecx
  836.         xor     eax, eax
  837.         ret
  838. @@:
  839.         add     ebx, 0x1FFF
  840.         shr     edx, 12
  841.         shr     ebx, 12
  842. ; edx = allocated size, ebx = new size
  843.         add     edx, ecx
  844.         add     ebx, ecx
  845.         cmp     edx, ebx
  846.         jb      .realloc_add
  847. ; release part of allocated memory
  848. .loop:
  849.         cmp     edx, ebx
  850.         jz      .release_done
  851.         dec     edx
  852.         xor     eax, eax
  853.         xchg    eax, [page_tabs+edx*4]
  854.         test    al, 1
  855.         jz      .loop
  856.         call    free_page
  857.         mov     eax, edx
  858.         shl     eax, 12
  859.         invlpg  [eax]
  860.         jmp     .loop
  861. .release_done:
  862.         sub     ebx, ecx
  863.         cmp     ebx, 1
  864.         jnz     .nofreeall
  865.         mov     eax, [page_tabs+ecx*4]
  866.         and     eax, not 0xFFF
  867.         mov     edx, [current_slot]
  868.         mov     ebx, [APPDATA.mem_size+edx]
  869.         sub     ebx, eax
  870.         add     ebx, 0x1000
  871.         or      al, FREE_BLOCK
  872.         mov     [page_tabs+ecx*4], eax
  873.         push    esi edi
  874.         mov     esi, [APPDATA.heap_base+edx]
  875.         mov     edi, [APPDATA.heap_top+edx]
  876.         call    update_mem_size
  877.         call    user_normalize
  878.         pop     edi esi
  879.         jmp     .ret0   ; all freed
  880. .nofreeall:
  881.         sub     edx, ecx
  882.         shl     ebx, 12
  883.         or      ebx, USED_BLOCK
  884.         xchg    [page_tabs+ecx*4], ebx
  885.         shr     ebx, 12
  886.         sub     ebx, edx
  887.         push    ebx ecx edx
  888.         mov     edx, [current_slot]
  889.         shl     ebx, 12
  890.         sub     ebx, [APPDATA.mem_size+edx]
  891.         neg     ebx
  892.         call    update_mem_size
  893.         pop     edx ecx ebx
  894.         lea     eax, [ecx+1]
  895.         shl     eax, 12
  896.         push    eax
  897.         add     ecx, ebx
  898.         add     edx, ecx
  899.         shl     ebx, 12
  900.         jz      .ret
  901.         push    esi
  902.         mov     esi, [current_slot]
  903.         mov     esi, [APPDATA.heap_top+esi]
  904.         shr     esi, 12
  905. @@:
  906.         cmp     edx, esi
  907.         jae     .merge_done
  908.         mov     eax, [page_tabs+edx*4]
  909.         test    al, USED_BLOCK
  910.         jz      .merge_done
  911.         and     dword [page_tabs+edx*4], 0
  912.         and     eax, not 0xFFF
  913.         add     ebx, eax
  914.         add     edx, eax
  915.         jmp     @b
  916. .merge_done:
  917.         pop     esi
  918.         or      ebx, FREE_BLOCK
  919.         mov     [page_tabs+ecx*4], ebx
  920. .ret:
  921.         pop     eax edx ecx
  922.         ret
  923. .realloc_add:
  924. ; get some additional memory
  925.         mov     eax, [current_slot]
  926.         mov     eax, [APPDATA.heap_top+eax]
  927.         shr     eax, 12
  928.         cmp     edx, eax
  929.         jae     .cant_inplace
  930.         mov     eax, [page_tabs+edx*4]
  931.         shr     eax, 12
  932.         add     eax, edx
  933.         cmp     eax, ebx
  934.         jb      .cant_inplace
  935.         sub     eax, ebx
  936.         jz      @f
  937.         shl     eax, 12
  938.         or      al, FREE_BLOCK
  939.         mov     [page_tabs+ebx*4], eax
  940. @@:
  941.         mov     eax, ebx
  942.         sub     eax, ecx
  943.         shl     eax, 12
  944.         or      al, USED_BLOCK
  945.         mov     [page_tabs+ecx*4], eax
  946.         lea     eax, [ecx+1]
  947.         shl     eax, 12
  948.         push    eax
  949.         push    edi
  950.         lea     edi, [page_tabs+edx*4]
  951.         mov     eax, 2
  952.         sub     ebx, edx
  953.         mov     ecx, ebx
  954.         cld
  955.         rep     stosd
  956.         pop     edi
  957.         mov     edx, [current_slot]
  958.         shl     ebx, 12
  959.         add     ebx, [APPDATA.mem_size+edx]
  960.         call    update_mem_size
  961.         pop     eax edx ecx
  962.         ret
  963. .cant_inplace:
  964.         push    esi edi
  965.         mov     eax, [current_slot]
  966.         mov     esi, [APPDATA.heap_base+eax]
  967.         mov     edi, [APPDATA.heap_top+eax]
  968.         shr     esi, 12
  969.         shr     edi, 12
  970.         sub     ebx, ecx
  971. .find_place:
  972.         cmp     esi, edi
  973.         jae     .place_not_found
  974.         mov     eax, [page_tabs+esi*4]
  975.         test    al, FREE_BLOCK
  976.         jz      .next_place
  977.         shr     eax, 12
  978.         cmp     eax, ebx
  979.         jae     .place_found
  980.         add     esi, eax
  981.         jmp     .find_place
  982. .next_place:
  983.         shr     eax, 12
  984.         add     esi, eax
  985.         jmp     .find_place
  986. .place_not_found:
  987.         pop     edi esi
  988.         jmp     .ret0
  989. .place_found:
  990.         sub     eax, ebx
  991.         jz      @f
  992.         push    esi
  993.         add     esi, eax
  994.         shl     eax, 12
  995.         or      al, FREE_BLOCK
  996.         mov     [page_tabs+esi*4], eax
  997.         pop     esi
  998. @@:
  999.         mov     eax, ebx
  1000.         shl     eax, 12
  1001.         or      al, USED_BLOCK
  1002.         mov     [page_tabs+esi*4], eax
  1003.         inc     esi
  1004.         mov     eax, esi
  1005.         shl     eax, 12
  1006.         push    eax
  1007.         mov     eax, [page_tabs+ecx*4]
  1008.         and     eax, not 0xFFF
  1009.         or      al, FREE_BLOCK
  1010.         sub     edx, ecx
  1011.         mov     [page_tabs+ecx*4], eax
  1012.         inc     ecx
  1013. @@:
  1014.         xor     eax, eax
  1015.         xchg    eax, [page_tabs+ecx*4]
  1016.         mov     [page_tabs+esi*4], eax
  1017.         mov     eax, ecx
  1018.         shl     eax, 12
  1019.         invlpg  [eax]
  1020.         inc     ecx
  1021.         inc     esi
  1022.         dec     ebx
  1023.         dec     edx
  1024.         jnz     @b
  1025.         push    ebx
  1026.         mov     edx, [current_slot]
  1027.         shl     ebx, 12
  1028.         add     ebx, [APPDATA.mem_size+edx]
  1029.         call    update_mem_size
  1030.         pop     ebx
  1031. @@:
  1032.         mov     dword [page_tabs+esi*4], 2
  1033.         inc     esi
  1034.         dec     ebx
  1035.         jnz     @b
  1036.         pop     eax edi esi edx ecx
  1037.         ret
  1038.  
  1039. if 0
  1040. align 4
  1041. proc alloc_dll
  1042.            pushf
  1043.            cli
  1044.            bsf eax, [dll_map]
  1045.            jnz .find
  1046.            popf
  1047.            xor eax, eax
  1048.            ret
  1049. .find:
  1050.            btr [dll_map], eax
  1051.            popf
  1052.            shl eax, 5
  1053.            add eax, dll_tab
  1054.            ret
  1055. endp
  1056.  
  1057. align 4
  1058. proc alloc_service
  1059.            pushf
  1060.            cli
  1061.            bsf eax, [srv_map]
  1062.            jnz .find
  1063.            popf
  1064.            xor eax, eax
  1065.            ret
  1066. .find:
  1067.            btr [srv_map], eax
  1068.            popf
  1069.            shl eax,0x02
  1070.            lea eax,[srv_tab+eax+eax*8]   ;srv_tab+eax*36
  1071.            ret
  1072. endp
  1073.  
  1074. end if
  1075.