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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 1055 $
 
 
align 4
proc alloc_page
 
           pushfd
           cli
           push ebx
           mov ebx, [page_start]
           mov ecx, [page_end]
.l1:
           bsf eax,[ebx];
           jnz .found
           add ebx,4
           cmp ebx, ecx
           jb .l1
           pop ebx
           popfd
           xor eax,eax
           ret
.found:
           btr [ebx], eax
           mov [page_start],ebx
           sub ebx, sys_pgmap
           lea eax, [eax+ebx*8]
           shl eax, 12
           dec [pg_data.pages_free]
           pop ebx
           popfd
           ret
endp
 
align 4
proc alloc_pages stdcall, count:dword
           pushfd
           push ebx
           push edi
           cli
           mov eax, [count]
           add eax, 7
           shr eax, 3
           mov [count], eax
           cmp eax, [pg_data.pages_free]
           ja .fail
 
           mov ecx, [page_start]
           mov ebx, [page_end]
.find:
           mov edx, [count]
           mov edi, ecx
.match:
           cmp byte [ecx], 0xFF
           jne .next
           dec edx
           jz .ok
           inc ecx
           cmp ecx,ebx
           jb .match
.fail:
           xor eax, eax
           pop edi
           pop ebx
           popfd
           ret
.next:
           inc ecx
           cmp ecx, ebx
           jb .find
           pop edi
           pop ebx
           popfd
           xor eax, eax
           ret
.ok:
           sub ecx, edi
           inc ecx
           push esi
           mov esi, edi
           xor eax, eax
           rep stosb
           sub esi, sys_pgmap
           shl esi, 3+12
           mov eax, esi
           mov ebx, [count]
           shl ebx, 3
           sub [pg_data.pages_free], ebx
           pop esi
           pop edi
           pop ebx
           popfd
           ret
endp
 
align 4
proc map_page stdcall,lin_addr:dword,phis_addr:dword,flags:dword
           push ebx
           mov eax, [phis_addr]
           and eax, not 0xFFF
           or eax, [flags]
           mov ebx, [lin_addr]
           shr ebx, 12
           mov [page_tabs+ebx*4], eax
           mov eax, [lin_addr]
           invlpg [eax]
           pop ebx
           ret
endp
 
align 4
map_space:    ;not implemented
 
 
           ret
 
 
align 4
proc free_page
;arg:  eax  page address
           pushfd
           cli
           shr eax, 12                        ;page index
           bts dword [sys_pgmap], eax         ;that's all!
           cmc
           adc [pg_data.pages_free], 0
           shr eax, 3
           and eax, not 3                     ;dword offset from page_map
           add eax, sys_pgmap
           cmp [page_start], eax
           ja @f
           popfd
           ret
@@:
           mov [page_start], eax
           popfd
           ret
endp
 
proc map_io_mem stdcall, base:dword, size:dword, flags:dword
 
           push ebx
           push edi
           mov eax, [size]
           add eax, 4095
           and eax, -4096
           mov [size], eax
           stdcall alloc_kernel_space, eax
           test eax, eax
           jz .fail
           push eax
 
           mov edi, 0x1000
           mov ebx, eax
           mov ecx,[size]
           mov edx, [base]
           shr eax, 12
           shr ecx, 12
           and edx, -4096
           or edx, [flags]
@@:
           mov [page_tabs+eax*4], edx
          ; push eax
          ; invlpg [ebx]
          ; pop eax
           inc eax
           add ebx, edi
           add edx, edi
           loop @B
 
           pop eax
           mov edx, [base]
           and edx, 4095
           add eax, edx
.fail:
           pop edi
           pop ebx
           ret
endp
 
; param
;  eax= page base + page flags
;  ebx= linear address
;  ecx= count
 
align 4
commit_pages:
           push edi
           test ecx, ecx
           jz .fail
 
           mov edi, ebx
           mov ebx, pg_data.pg_mutex
           call wait_mutex      ;ebx
 
           mov edx, 0x1000
           mov ebx, edi
           shr ebx, 12
@@:
           mov [page_tabs+ebx*4], eax
          ; push eax
          ; invlpg [edi]
          ; pop eax
           add edi, edx
           add eax, edx
           inc ebx
           dec ecx
           jnz @B
           mov [pg_data.pg_mutex],ecx
.fail:
           pop edi
           ret
 
 
; param
;  eax= base
;  ecx= count
 
align 4
release_pages:
 
           pushad
           mov ebx, pg_data.pg_mutex
           call wait_mutex      ;ebx
 
           mov esi, eax
           mov edi, eax
 
           shr esi, 10
           add esi, page_tabs
 
           mov ebp, [pg_data.pages_free]
           mov ebx, [page_start]
           mov edx, sys_pgmap
@@:
           xor eax, eax
           xchg eax, [esi]
           push eax
           invlpg [edi]
           pop eax
 
           test eax, 1
           jz .next
 
           shr eax, 12
           bts [edx], eax
           cmc
           adc ebp, 0
           shr eax, 3
           and eax, -4
           add eax, edx
           cmp eax, ebx
           jae .next
 
           mov ebx, eax
.next:
           add edi, 0x1000
           add esi, 4
           dec ecx
           jnz @B
           mov [pg_data.pages_free], ebp
           and [pg_data.pg_mutex],0
           popad
           ret
 
; param
;  eax= base
;  ecx= count
 
align 4
unmap_pages:
 
           push edi
 
           mov edi, eax
           mov edx, eax
 
           shr edi, 10
           add edi, page_tabs
 
           xor eax, eax
@@:
           stosd
           invlpg [edx]
           add edx, 0x1000
           loop @b
 
           pop edi
           ret
 
 
align 4
proc map_page_table stdcall, lin_addr:dword, phis_addr:dword
           push ebx
           mov ebx, [lin_addr]
           shr ebx, 22
           mov eax, [phis_addr]
           and eax, not 0xFFF
           or eax, PG_UW          ;+PG_NOCACHE
           mov dword [master_tab+ebx*4], eax
           mov eax, [lin_addr]
           shr eax, 10
           add eax, page_tabs
           invlpg [eax]
           pop ebx
           ret
endp
 
align 4
proc init_LFB
           locals
             pg_count dd ?
           endl
 
           cmp dword [LFBAddress], -1
           jne @f
           mov [BOOT_VAR+0x901c],byte 2
           stdcall kernel_alloc, 0x280000
           mov [LFBAddress], eax
           ret
@@:
           test [SCR_MODE],word 0100000000000000b
           jnz @f
           mov [BOOT_VAR+0x901c],byte 2
           ret
@@:
           call init_mtrr
 
           mov edx, LFB_BASE
           mov esi, [LFBAddress]
           mov edi, 0x00800000
           mov dword [exp_lfb+4], edx
 
           shr edi, 12
           mov [pg_count], edi
           shr edi, 10
 
           bt [cpu_caps], CAPS_PSE
           jnc .map_page_tables
           or esi, PG_LARGE+PG_UW
           mov edx, sys_pgdir+(LFB_BASE shr 20)
@@:
           mov [edx], esi
           add edx, 4
           add esi, 0x00400000
           dec edi
           jnz @B
 
           bt [cpu_caps], CAPS_PGE
           jnc @F
           or dword [sys_pgdir+(LFB_BASE shr 20)], PG_GLOBAL
@@:
           mov dword [LFBAddress], LFB_BASE
           mov eax, cr3       ;flush TLB
           mov cr3, eax
           ret
 
.map_page_tables:
 
@@:
           call alloc_page
           stdcall map_page_table, edx, eax
           add edx, 0x00400000
           dec edi
           jnz @B
 
           mov eax, [LFBAddress]
           mov edi, page_tabs + (LFB_BASE shr 10)
           or eax, PG_UW
           mov ecx, [pg_count]
           cld
@@:
           stosd
           add eax, 0x1000
           dec ecx
           jnz @B
 
           mov dword [LFBAddress], LFB_BASE
           mov eax, cr3       ;flush TLB
           mov cr3, eax
 
           ret
endp
 
align 4
proc new_mem_resize stdcall, new_size:dword
 
           mov ebx, pg_data.pg_mutex
           call wait_mutex    ;ebx
 
           mov edi, [new_size]
           add edi,4095
           and edi,not 4095
           mov [new_size], edi
 
           mov edx,[current_slot]
           cmp [edx+APPDATA.heap_base],0
           jne .exit
 
           mov esi, [edx+APPDATA.mem_size]
           add esi, 4095
           and esi, not 4095
 
           cmp edi, esi
           jae .expand
 
           shr edi, 12
           shr esi, 12
@@:
           mov eax, [app_page_tabs+edi*4]
           test eax, 1
           jz .next
           mov dword [app_page_tabs+edi*4], 2
           mov ebx, edi
           shl ebx, 12
           push eax
           invlpg [ebx]
           pop eax
           call free_page
 
.next:     add edi, 1
           cmp edi, esi
           jb @B
 
.update_size:
           mov     ebx, [new_size]
           call    update_mem_size
 
           xor eax, eax
           dec [pg_data.pg_mutex]
           ret
.expand:
 
           push esi
           push edi
 
           add edi, 0x3FFFFF
           and edi, not(0x3FFFFF)
           add esi, 0x3FFFFF
           and esi, not(0x3FFFFF)
 
           cmp esi, edi
           jae .grow
 
           xchg esi, edi
 
@@:
           call alloc_page
           test eax, eax
           jz .exit
 
           stdcall map_page_table, edi, eax
 
           push edi
           shr edi, 10
           add edi, page_tabs
           mov ecx, 1024
           xor eax, eax
           cld
           rep stosd
           pop edi
 
           add edi, 0x00400000
           cmp edi, esi
           jb @B
.grow:
           pop edi
           pop esi
@@:
           call alloc_page
           test eax, eax
           jz .exit
           stdcall map_page,esi,eax,dword PG_UW
 
           push edi
           mov edi, esi
           xor eax, eax
           mov ecx, 1024
           cld
           rep stosd
           pop edi
 
           add esi, 0x1000
           cmp esi, edi
           jb  @B
 
           jmp .update_size
.exit:
           xor eax, eax
           inc eax
           dec [pg_data.pg_mutex]
           ret
endp
 
update_mem_size:
; in: edx = slot base
;     ebx = new memory size
; destroys eax,ecx,edx
 
           mov    [APPDATA.mem_size+edx],ebx
;search threads and update
;application memory size infomation
           mov    ecx,[APPDATA.dir_table+edx]
           mov    eax,2
 
.search_threads:
;eax = current slot
;ebx = new memory size
;ecx = page directory
           cmp    eax,[TASK_COUNT]
           jg     .search_threads_end
           mov    edx,eax
           shl    edx,5
           cmp    word [CURRENT_TASK+edx+TASKDATA.state],9 ;if slot empty?
           jz     .search_threads_next
           shl    edx,3
           cmp    [SLOT_BASE+edx+APPDATA.dir_table],ecx     ;if it is our thread?
           jnz    .search_threads_next
           mov    [SLOT_BASE+edx+APPDATA.mem_size],ebx     ;update memory size
.search_threads_next:
           inc    eax
           jmp    .search_threads
.search_threads_end:
           ret
 
; param
;  eax= linear address
;
; retval
;  eax= phisical page address
 
align 4
get_pg_addr:
           shr eax, 12
           mov eax, [page_tabs+eax*4]
           and eax, 0xFFFFF000
           ret
 
 
align 4
proc page_fault_handler
 
        test    byte [esp+12+2], 2
        jnz     v86_page_fault
 
        .err_code equ ebp+32
        .err_addr equ ebp-4
 
           pushad
           mov ebp, esp
           mov eax, cr2
           push eax
 
           mov ax, app_data
           mov ds, ax
           mov es, ax
 
           inc [pg_data.pages_faults]
 
;     push eax
;     push edx
;     mov edx, 0x400   ;bochs
;     mov al,0xff      ;bochs
;     out dx, al       ;bochs
;     pop edx
;     pop eax
 
           mov ebx, [.err_addr]
           mov eax, [.err_code]
 
           cmp ebx, OS_BASE
           jb .user_space      ;ñòðàíèöà â ïàìÿòè ïðèëîæåíèÿ ;
 
           cmp ebx, page_tabs
           jb .kernel_space    ;ñòðàíèöà â ïàìÿòè ÿäðà
 
           cmp ebx, kernel_tabs
           jb .alloc;.app_tabs ;òàáëèöû ñòðàíèö ïðèëîæåíèÿ ;
                               ;ïðîñòî ñîçäàäèì îäíó
 
           cmp ebx, LFB_BASE
           jb .core_tabs       ;òàáëèöû ñòðàíèö ÿäðà
                               ;Îøèáêà
.lfb:
                               ;îáëàñòü LFB
                               ;Îøèáêà
           jmp .fail
 
align 4
.user_space:
           test eax, PG_MAP
           jnz .err_access     ;Ñòðàíèöà ïðèñóòñòâóåò
                               ;Îøèáêà äîñòóïà ?
 
           shr ebx, 12
           mov ecx, ebx
           shr ecx, 10
           mov edx, [master_tab+ecx*4]
           test edx, PG_MAP
           jz .fail            ;òàáëèöà ñòðàíèö íå ñîçäàíà
                               ;íåâåðíûé àäðåñ â ïðîãðàììå
 
           mov eax, [page_tabs+ebx*4]
           test eax, 2
           jz .fail            ;àäðåñ íå çàðåçåðâèðîâàí äëÿ ;
                               ;èñïîëüçîâàíèÿ. Îøèáêà
.alloc:
           call alloc_page
           test eax, eax
           jz .fail
 
           stdcall map_page,[ebp-4],eax,dword PG_UW
 
           mov edi, [ebp-4]
           and edi, 0xFFFFF000
           mov ecx, 1024
           xor eax, eax
           cld
           rep stosd
.exit:
           mov esp, ebp
           popad
           add esp, 4
           iretd
 
.err_access:
;íèêîãäà íå ïðîèñõîäèò
           jmp .fail
 
.kernel_space:
           test eax, PG_MAP
           jz .fail        ;ñòðàíèöà íå ïðèñóòñòâóåò
 
           test eax, 4     ;U/S
           jnz .fail       ;ïðèëîæåíèå îáðàòèëîñü ê ïàìÿòè
                           ;ÿäðà
           test eax, 8
           jnz .fail       ;óñòàíîâëåí çàðåçåðâèðîâàííûé áèò
                           ;â òàáëèöàõ ñòðàíèö. äîáàâëåíî â P4/Xeon
 
;ïîïûòêà çàïèñè â çàùèù¸ííóþ ñòðàíèöó ÿäðà
 
           cmp ebx, tss._io_map_0
           jb .fail
 
           cmp ebx, tss._io_map_0+8192
           jae .fail
 
; io permission map
; copy-on-write protection
 
           call alloc_page
           test eax, eax
           jz .fail
 
           push eax
           stdcall map_page,[ebp-4],eax,dword PG_SW
           pop eax
           mov edi, [.err_addr]
           and edi, -4096
           lea esi, [edi+(not tss._io_map_0)+1]; -tss._io_map_0
 
           mov ebx, esi
           shr ebx, 12
           mov edx, [current_slot]
           or eax, PG_SW
           mov [edx+APPDATA.io_map+ebx*4], eax
 
           add esi, [default_io_map]
           mov ecx, 4096/4
           cld
           rep movsd
           jmp .exit
 
 
;íå îáðàáàòûâàåì. Îøèáêà
 
.core_tabs:
.fail:
           mov esp, ebp
           popad
           add esp, 4
 
;           iretd
 
           save_ring3_context     ;debugger support
 
           mov bl, 14
           jmp exc_c
           iretd
endp
 
align 4
proc map_mem stdcall, lin_addr:dword,pdir:dword,\
                      ofs:dword,buf_size:dword
           mov eax, [buf_size]
           test eax, eax
           jz .exit
 
           mov eax, [pdir]
           and eax, 0xFFFFF000
 
           stdcall map_page,[ipc_pdir],eax,PG_UW
           mov ebx, [ofs]
           shr ebx, 22
           mov esi, [ipc_pdir]
           mov edi, [ipc_ptab]
           mov eax, [esi+ebx*4]
           and eax, 0xFFFFF000
           jz .exit
           stdcall map_page,edi,eax,PG_UW
;           inc ebx
;           add edi, 0x1000
;           mov eax, [esi+ebx*4]
;           test eax, eax
;           jz @f
;          and eax, 0xFFFFF000
;           stdcall map_page, edi, eax
 
@@:        mov edi, [lin_addr]
           and edi, 0xFFFFF000
           mov ecx, [buf_size]
           add ecx, 4095
           shr ecx, 12
           inc ecx
 
           mov edx, [ofs]
           shr edx, 12
           and edx, 0x3FF
           mov esi, [ipc_ptab]
 
.map:      mov eax, [esi+edx*4]
           and eax, 0xFFFFF000
           jz  .exit
           stdcall map_page,edi,eax,PG_UW
           dec ecx
           jz  .exit
           add edi, 0x1000
           inc edx
           cmp edx, 0x400
           jnz .map
           inc ebx
           mov eax, [ipc_pdir]
           mov eax, [eax+ebx*4]
           and eax, 0xFFFFF000
           jz  .exit
           stdcall map_page,esi,eax,PG_UW
           xor edx, edx
           jmp .map
 
.exit:
           ret
endp
 
align 4
proc map_memEx stdcall, lin_addr:dword,pdir:dword,\
                        ofs:dword,buf_size:dword
           mov eax, [buf_size]
           test eax, eax
           jz .exit
 
           mov eax, [pdir]
           and eax, 0xFFFFF000
 
           stdcall map_page,[proc_mem_pdir],eax,dword PG_UW
           mov ebx, [ofs]
           shr ebx, 22
           mov esi, [proc_mem_pdir]
           mov edi, [proc_mem_tab]
           mov eax, [esi+ebx*4]
           and eax, 0xFFFFF000
           test eax, eax
           jz .exit
           stdcall map_page,edi,eax,dword PG_UW
 
@@:        mov edi, [lin_addr]
           and edi, 0xFFFFF000
           mov ecx, [buf_size]
           add ecx, 4095
           shr ecx, 12
           inc ecx
 
           mov edx, [ofs]
           shr edx, 12
           and edx, 0x3FF
           mov esi, [proc_mem_tab]
 
.map:      mov eax, [esi+edx*4]
;           and eax, 0xFFFFF000
;           test eax, eax
;           jz .exit
           stdcall map_page,edi,eax,dword PG_UW
           add edi, 0x1000
           inc edx
           dec ecx
           jnz .map
.exit:
           ret
endp
 
 
 
 
sys_IPC:
;input:
;  eax=1 - set ipc buffer area
;    ebx=address of buffer
;    ecx=size of buffer
;  eax=2 - send message
;    ebx=PID
;    ecx=address of message
;    edx=size of message
 
           cmp  eax,1
           jne @f
           call set_ipc_buff
           mov [esp+36], eax
           ret
@@:
           cmp eax, 2
           jne @f
           stdcall sys_ipc_send, ebx, ecx, edx
           mov [esp+36], eax
           ret
@@:
           xor eax, eax
           not eax
           mov [esp+36], eax
           ret
 
align 4
proc set_ipc_buff
 
           mov  eax,[current_slot]
           pushf
           cli
           mov  [eax+APPDATA.ipc_start],ebx     ;set fields in extended information area
           mov  [eax+APPDATA.ipc_size],ecx
 
           add ecx, ebx
           add ecx, 4095
           and ecx, not 4095
 
.touch:    mov eax, [ebx]
           add ebx, 0x1000
           cmp ebx, ecx
           jb  .touch
 
           popf
           xor eax, eax
           ret
endp
 
proc sys_ipc_send stdcall, PID:dword, msg_addr:dword, msg_size:dword
           locals
             dst_slot   dd ?
             dst_offset dd ?
             buf_size   dd ?
             used_buf   dd ?
           endl
 
           pushf
           cli
 
           mov  eax, [PID]
           call pid_to_slot
           test eax,eax
           jz   .no_pid
 
           mov [dst_slot], eax
           shl  eax,8
           mov  edi,[eax+SLOT_BASE+0xa0]  ;is ipc area defined?
           test edi,edi
           jz   .no_ipc_area
 
           mov ebx, edi
           and ebx, 0xFFF
           mov [dst_offset], ebx
 
           mov esi, [eax+SLOT_BASE+0xa4]
           mov [buf_size], esi
 
           mov ecx, [ipc_tmp]
           cmp esi, 0x40000-0x1000 ; size of [ipc_tmp] minus one page
           jbe @f
           push eax esi edi
           add esi,0x1000
           stdcall alloc_kernel_space,esi
           mov ecx, eax
           pop edi esi eax
@@:
           mov [used_buf], ecx
           stdcall map_mem, ecx, [SLOT_BASE+eax+0xB8],\
                             edi, esi
 
           mov edi, [dst_offset]
           add edi, [used_buf]
           cmp dword [edi], 0
           jnz  .ipc_blocked          ;if dword [buffer]<>0 - ipc blocked now
 
           mov edx, dword [edi+4]
           lea ebx, [edx+8]
           add ebx, [msg_size]
           cmp ebx, [buf_size]
           ja .buffer_overflow         ;esi<0 - not enough memory in buffer
 
           mov dword [edi+4], ebx
           mov eax,[TASK_BASE]
           mov eax, [eax+0x04]         ;eax - our PID
           add edi, edx
           mov [edi], eax
           mov ecx, [msg_size]
 
           mov [edi+4], ecx
           add edi, 8
           mov esi, [msg_addr]
       ;    add esi, new_app_base
           cld
           rep movsb
 
           mov ebx, [ipc_tmp]
           mov edx, ebx
           shr ebx, 12
           xor eax, eax
           mov [page_tabs+ebx*4], eax
           invlpg [edx]
 
           mov ebx, [ipc_pdir]
           mov edx, ebx
           shr ebx, 12
           xor eax, eax
           mov [page_tabs+ebx*4], eax
           invlpg [edx]
 
           mov ebx, [ipc_ptab]
           mov edx, ebx
           shr ebx, 12
           xor eax, eax
           mov [page_tabs+ebx*4], eax
           invlpg [edx]
 
           mov  eax, [dst_slot]
           shl eax, 8
           or   [eax+SLOT_BASE+0xA8],dword 0x40
           cmp  dword [check_idle_semaphore],20
           jge  .ipc_no_cis
 
           mov  dword [check_idle_semaphore],5
.ipc_no_cis:
           push 0
           jmp .ret
.no_pid:
           popf
           mov eax, 4
           ret
.no_ipc_area:
           popf
           xor eax, eax
           inc eax
           ret
.ipc_blocked:
           push 2
           jmp .ret
.buffer_overflow:
           push 3
.ret:
           mov eax, [used_buf]
           cmp eax, [ipc_tmp]
           jz @f
           stdcall free_kernel_space,eax
@@:
           pop eax
           popf
           ret
endp
 
align 4
sysfn_meminfo:
 
        ;   add ebx, new_app_base
           cmp ebx, OS_BASE
           jae .fail
 
           mov eax, [pg_data.pages_count]
           mov [ebx], eax
           shl eax, 12
           mov [esp+36], eax
           mov ecx, [pg_data.pages_free]
           mov [ebx+4], ecx
           mov edx, [pg_data.pages_faults]
           mov [ebx+8], edx
           mov esi, [heap_size]
           mov [ebx+12], esi
           mov edi, [heap_free]
           mov [ebx+16], edi
           mov eax, [heap_blocks]
           mov [ebx+20], eax
           mov ecx, [free_blocks]
           mov [ebx+24], ecx
           ret
.fail:
           mov dword [esp+36], -1
           ret
 
align 4
f68call:
           dd f68.11
           dd f68.12
           dd f68.13
           dd f68.14
           dd f68.15
           dd f68.16
           dd f68.17
           dd f68.18
           dd f68.19
           dd f68.20
           dd f68.21
           dd f68.22
           dd f68.23
 
align 4
f68:
           cmp  eax,4
           jle  sys_sheduler
 
           cmp eax, 11
           jb .fail
 
           cmp eax, 23
           ja .fail
 
           jmp dword [f68call+eax*4-11*4]
.11:
           call init_heap
           mov [esp+36], eax
           ret
.12:
           stdcall user_alloc, ebx
           mov [esp+36], eax
           ret
.13:
           stdcall user_free, ebx
           mov [esp+36], eax
           ret
.14:
           cmp ebx, OS_BASE
           jae .fail
           mov edi,ebx
           call get_event_ex
           mov [esp+36], eax
           ret
.15:
           mov ecx, [current_slot]
           mov eax, [ecx+APPDATA.fpu_handler]
           mov [ecx+APPDATA.fpu_handler], ebx
           mov [esp+36], eax
           ret
.16:
           test ebx, ebx
           jz .fail
           cmp ebx, OS_BASE
           jae .fail
           stdcall get_service, ebx
           mov [esp+36], eax
           ret
.17:
           call srv_handlerEx   ;ebx
           mov [esp+36], eax
           ret
.18:
           mov ecx, [current_slot]
           mov eax, [ecx+APPDATA.sse_handler]
           mov [ecx+APPDATA.sse_handler], ebx
           mov [esp+36], eax
           ret
.19:
           cmp ebx, OS_BASE
           jae .fail
           stdcall load_library, ebx
           mov [esp+36], eax
           ret
.20:
           mov     eax, ecx
           call    user_realloc
           mov     [esp+36], eax
           ret
.21:
           cmp ebx, OS_BASE
           jae .fail
 
           stdcall load_PE, ebx
 
           test eax, eax
           jz @F
 
           mov esi, eax
           stdcall eax, DRV_ENTRY
 
           test eax, eax
           jz @F
 
           mov [eax+SRV.entry], esi
 
@@:
           mov [esp+36], eax
           ret
.22:
           cmp ebx, OS_BASE
           jae .fail
 
           stdcall shmem_open, ebx, ecx, edx
           mov [esp+28], edx
           mov [esp+36], eax
           ret
 
.23:
           cmp ebx, OS_BASE
           jae .fail
 
           stdcall shmem_close, ebx
           mov [esp+36], eax
           ret
 
.fail:
           xor eax, eax
           mov [esp+36], eax
           ret
 
align 4
proc load_pe_driver stdcall, file:dword
 
           stdcall load_PE, [file]
           test eax, eax
           jz .fail
 
           mov esi, eax
           stdcall eax, DRV_ENTRY
           test eax, eax
           jz .fail
 
           mov [eax+SRV.entry], esi
           ret
 
.fail:
           xor eax, eax
           ret
endp
 
 
align 4
proc init_mtrr
 
           cmp [BOOT_VAR+0x901c],byte 2
           je  .exit
 
           bt [cpu_caps], CAPS_MTRR
           jnc .exit
 
           mov eax, cr0
           or eax, 0x60000000   ;disable caching
           mov cr0, eax
           wbinvd               ;invalidate cache
 
           mov ecx, 0x2FF
           rdmsr                ;
; has BIOS already initialized MTRRs?
           test ah, 8
           jnz .skip_init
; rarely needed, so mainly placeholder
; main memory - cached
           push eax
 
           mov eax, [MEM_AMOUNT]
; round eax up to next power of 2
           dec eax
           bsr ecx, eax
           mov ebx, 2
           shl ebx, cl
           dec ebx
; base of memory range = 0, type of memory range = MEM_WB
           xor edx, edx
           mov eax, MEM_WB
           mov ecx, 0x200
           wrmsr
; mask of memory range = 0xFFFFFFFFF - (size - 1), ebx = size - 1
           mov eax, 0xFFFFFFFF
           mov edx, 0x0000000F
           sub eax, ebx
           sbb edx, 0
           or eax, 0x800
           inc ecx
           wrmsr
; clear unused MTRRs
           xor eax, eax
           xor edx, edx
@@:
           wrmsr
           inc ecx
           cmp ecx, 0x210
           jb @b
; enable MTRRs
           pop eax
           or ah, 8
           and al, 0xF0 ; default memtype = UC
           mov ecx, 0x2FF
           wrmsr
.skip_init:
           stdcall set_mtrr, [LFBAddress],[LFBSize],MEM_WC
 
           wbinvd               ;again invalidate
 
           mov eax, cr0
           and eax, not 0x60000000
           mov cr0, eax         ; enable caching
.exit:
           ret
endp
 
align 4
proc set_mtrr stdcall, base:dword,size:dword,mem_type:dword
; find unused register
           mov ecx, 0x201
@@:
           rdmsr
           dec ecx
           test ah, 8
           jz .found
           rdmsr
           mov al, 0 ; clear memory type field
           cmp eax, [base]
           jz .ret
           add ecx, 3
           cmp ecx, 0x210
           jb @b
; no free registers, ignore the call
.ret:
           ret
.found:
; found, write values
           xor edx, edx
           mov eax, [base]
           or eax, [mem_type]
           wrmsr
 
           mov ebx, [size]
           dec ebx
           mov eax, 0xFFFFFFFF
           mov edx, 0x0000000F
           sub eax, ebx
           sbb edx, 0
           or eax, 0x800
           inc ecx
           wrmsr
           ret
endp
 
align 4
proc stall stdcall, delay:dword
           push ecx
           push edx
           push ebx
           push eax
 
           mov eax, [delay]
           mul [stall_mcs]
           mov ebx, eax       ;low
           mov ecx, edx       ;high
           rdtsc
           add ebx, eax
           adc ecx,edx
@@:
           rdtsc
           sub eax, ebx
           sbb edx, ecx
           jb @B
 
           pop eax
           pop ebx
           pop edx
           pop ecx
           ret
endp
 
align 4
proc create_ring_buffer stdcall, size:dword, flags:dword
           locals
             buf_ptr  dd ?
           endl
 
           mov eax, [size]
           test eax, eax
           jz .fail
 
           add eax, eax
           stdcall alloc_kernel_space, eax
           test eax, eax
           jz .fail
 
           push ebx
 
           mov [buf_ptr], eax
 
           mov ebx, [size]
           shr ebx, 12
           push ebx
 
           stdcall alloc_pages, ebx
           pop ecx
 
           test eax, eax
           jz .mm_fail
 
           push edi
 
           or eax, [flags]
           mov edi, [buf_ptr]
           mov ebx, [buf_ptr]
           mov edx, ecx
           shl edx, 2
           shr edi, 10
@@:
           mov [page_tabs+edi], eax
           mov [page_tabs+edi+edx], eax
           invlpg [ebx]
           invlpg [ebx+0x10000]
           add eax, 0x1000
           add ebx, 0x1000
           add edi, 4
           dec ecx
           jnz @B
 
           mov eax, [buf_ptr]
           pop edi
           pop ebx
           ret
.mm_fail:
           stdcall free_kernel_space, [buf_ptr]
           xor eax, eax
           pop ebx
.fail:
           ret
endp

Rev 1030	Rev 1055
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7		7
8	$Revision: 1030 $	8	$Revision: 1055 $
9		9
10		10
11	align 4	11	align 4
12	proc alloc_page	12	proc alloc_page
13		13
14	pushfd	14	pushfd
15	cli	15	cli
16	push ebx	16	push ebx
17	mov ebx, [page_start]	17	mov ebx, [page_start]
18	mov ecx, [page_end]	18	mov ecx, [page_end]
19	.l1:	19	.l1:
20	bsf eax,[ebx];	20	bsf eax,[ebx];
21	jnz .found	21	jnz .found
22	add ebx,4	22	add ebx,4
23	cmp ebx, ecx	23	cmp ebx, ecx
24	jb .l1	24	jb .l1
25	pop ebx	25	pop ebx
26	popfd	26	popfd
27	xor eax,eax	27	xor eax,eax
28	ret	28	ret
29	.found:	29	.found:
30	btr [ebx], eax	30	btr [ebx], eax
31	mov [page_start],ebx	31	mov [page_start],ebx
32	sub ebx, sys_pgmap	32	sub ebx, sys_pgmap
33	lea eax, [eax+ebx*8]	33	lea eax, [eax+ebx*8]
34	shl eax, 12	34	shl eax, 12
35	dec [pg_data.pages_free]	35	dec [pg_data.pages_free]
36	pop ebx	36	pop ebx
37	popfd	37	popfd
38	ret	38	ret
39	endp	39	endp
40		40
41	align 4	41	align 4
42	proc alloc_pages stdcall, count:dword	42	proc alloc_pages stdcall, count:dword
43	pushfd	43	pushfd
44	push ebx	44	push ebx
45	push edi	45	push edi
46	cli	46	cli
47	mov eax, [count]	47	mov eax, [count]
48	add eax, 7	48	add eax, 7
49	shr eax, 3	49	shr eax, 3
50	mov [count], eax	50	mov [count], eax
51	cmp eax, [pg_data.pages_free]	51	cmp eax, [pg_data.pages_free]
52	ja .fail	52	ja .fail
53		53
54	mov ecx, [page_start]	54	mov ecx, [page_start]
55	mov ebx, [page_end]	55	mov ebx, [page_end]
56	.find:	56	.find:
57	mov edx, [count]	57	mov edx, [count]
58	mov edi, ecx	58	mov edi, ecx
59	.match:	59	.match:
60	cmp byte [ecx], 0xFF	60	cmp byte [ecx], 0xFF
61	jne .next	61	jne .next
62	dec edx	62	dec edx
63	jz .ok	63	jz .ok
64	inc ecx	64	inc ecx
65	cmp ecx,ebx	65	cmp ecx,ebx
66	jb .match	66	jb .match
67	.fail:	67	.fail:
68	xor eax, eax	68	xor eax, eax
69	pop edi	69	pop edi
70	pop ebx	70	pop ebx
71	popfd	71	popfd
72	ret	72	ret
73	.next:	73	.next:
74	inc ecx	74	inc ecx
75	cmp ecx, ebx	75	cmp ecx, ebx
76	jb .find	76	jb .find
77	pop edi	77	pop edi
78	pop ebx	78	pop ebx
79	popfd	79	popfd
80	xor eax, eax	80	xor eax, eax
81	ret	81	ret
82	.ok:	82	.ok:
83	sub ecx, edi	83	sub ecx, edi
84	inc ecx	84	inc ecx
85	push esi	85	push esi
86	mov esi, edi	86	mov esi, edi
87	xor eax, eax	87	xor eax, eax
88	rep stosb	88	rep stosb
89	sub esi, sys_pgmap	89	sub esi, sys_pgmap
90	shl esi, 3+12	90	shl esi, 3+12
91	mov eax, esi	91	mov eax, esi
92	mov ebx, [count]	92	mov ebx, [count]
93	shl ebx, 3	93	shl ebx, 3
94	sub [pg_data.pages_free], ebx	94	sub [pg_data.pages_free], ebx
95	pop esi	95	pop esi
96	pop edi	96	pop edi
97	pop ebx	97	pop ebx
98	popfd	98	popfd
99	ret	99	ret
100	endp	100	endp
101		101
102	align 4	102	align 4
103	proc map_page stdcall,lin_addr:dword,phis_addr:dword,flags:dword	103	proc map_page stdcall,lin_addr:dword,phis_addr:dword,flags:dword
104	push ebx	104	push ebx
105	mov eax, [phis_addr]	105	mov eax, [phis_addr]
106	and eax, not 0xFFF	106	and eax, not 0xFFF
107	or eax, [flags]	107	or eax, [flags]
108	mov ebx, [lin_addr]	108	mov ebx, [lin_addr]
109	shr ebx, 12	109	shr ebx, 12
110	mov [page_tabs+ebx*4], eax	110	mov [page_tabs+ebx*4], eax
111	mov eax, [lin_addr]	111	mov eax, [lin_addr]
112	invlpg [eax]	112	invlpg [eax]
113	pop ebx	113	pop ebx
114	ret	114	ret
115	endp	115	endp
116		116
117	align 4	117	align 4
118	map_space: ;not implemented	118	map_space: ;not implemented
119		119
120		120
121	ret	121	ret
122		122
123		123
124	align 4	124	align 4
125	proc free_page	125	proc free_page
126	;arg: eax page address	126	;arg: eax page address
127	pushfd	127	pushfd
128	cli	128	cli
129	shr eax, 12 ;page index	129	shr eax, 12 ;page index
130	bts dword [sys_pgmap], eax ;that's all!	130	bts dword [sys_pgmap], eax ;that's all!
131	cmc	131	cmc
132	adc [pg_data.pages_free], 0	132	adc [pg_data.pages_free], 0
133	shr eax, 3	133	shr eax, 3
134	and eax, not 3 ;dword offset from page_map	134	and eax, not 3 ;dword offset from page_map
135	add eax, sys_pgmap	135	add eax, sys_pgmap
136	cmp [page_start], eax	136	cmp [page_start], eax
137	ja @f	137	ja @f
138	popfd	138	popfd
139	ret	139	ret
140	@@:	140	@@:
141	mov [page_start], eax	141	mov [page_start], eax
142	popfd	142	popfd
143	ret	143	ret
144	endp	144	endp
145		145
146	proc map_io_mem stdcall, base:dword, size:dword, flags:dword	146	proc map_io_mem stdcall, base:dword, size:dword, flags:dword
147		147
148	push ebx	148	push ebx
149	push edi	149	push edi
150	mov eax, [size]	150	mov eax, [size]
151	add eax, 4095	151	add eax, 4095
152	and eax, -4096	152	and eax, -4096
153	mov [size], eax	153	mov [size], eax
154	stdcall alloc_kernel_space, eax	154	stdcall alloc_kernel_space, eax
155	test eax, eax	155	test eax, eax
156	jz .fail	156	jz .fail
157	push eax	157	push eax
158		158
159	mov edi, 0x1000	159	mov edi, 0x1000
160	mov ebx, eax	160	mov ebx, eax
161	mov ecx,[size]	161	mov ecx,[size]
162	mov edx, [base]	162	mov edx, [base]
163	shr eax, 12	163	shr eax, 12
164	shr ecx, 12	164	shr ecx, 12
165	and edx, -4096	165	and edx, -4096
166	or edx, [flags]	166	or edx, [flags]
167	@@:	167	@@:
168	mov [page_tabs+eax*4], edx	168	mov [page_tabs+eax*4], edx
169	; push eax	169	; push eax
170	; invlpg [ebx]	170	; invlpg [ebx]
171	; pop eax	171	; pop eax
172	inc eax	172	inc eax
173	add ebx, edi	173	add ebx, edi
174	add edx, edi	174	add edx, edi
175	loop @B	175	loop @B
176		176
177	pop eax	177	pop eax
178	mov edx, [base]	178	mov edx, [base]
179	and edx, 4095	179	and edx, 4095
180	add eax, edx	180	add eax, edx
181	.fail:	181	.fail:
182	pop edi	182	pop edi
183	pop ebx	183	pop ebx
184	ret	184	ret
185	endp	185	endp
186		186
187	; param	187	; param
188	; eax= page base + page flags	188	; eax= page base + page flags
189	; ebx= linear address	189	; ebx= linear address
190	; ecx= count	190	; ecx= count
191		191
192	align 4	192	align 4
193	commit_pages:	193	commit_pages:
194	push edi	194	push edi
195	test ecx, ecx	195	test ecx, ecx
196	jz .fail	196	jz .fail
197		197
198	mov edi, ebx	198	mov edi, ebx
199	mov ebx, pg_data.pg_mutex	199	mov ebx, pg_data.pg_mutex
200	call wait_mutex ;ebx	200	call wait_mutex ;ebx
201		201
202	mov edx, 0x1000	202	mov edx, 0x1000
203	mov ebx, edi	203	mov ebx, edi
204	shr ebx, 12	204	shr ebx, 12
205	@@:	205	@@:
206	mov [page_tabs+ebx*4], eax	206	mov [page_tabs+ebx*4], eax
207	; push eax	207	; push eax
208	; invlpg [edi]	208	; invlpg [edi]
209	; pop eax	209	; pop eax
210	add edi, edx	210	add edi, edx
211	add eax, edx	211	add eax, edx
212	inc ebx	212	inc ebx
213	dec ecx	213	dec ecx
214	jnz @B	214	jnz @B
215	mov [pg_data.pg_mutex],ecx	215	mov [pg_data.pg_mutex],ecx
216	.fail:	216	.fail:
217	pop edi	217	pop edi
218	ret	218	ret
219		219
220		220
221	; param	221	; param
222	; eax= base	222	; eax= base
223	; ecx= count	223	; ecx= count
224		224
225	align 4	225	align 4
226	release_pages:	226	release_pages:
227		227
228	pushad	228	pushad
229	mov ebx, pg_data.pg_mutex	229	mov ebx, pg_data.pg_mutex
230	call wait_mutex ;ebx	230	call wait_mutex ;ebx
231		231
232	mov esi, eax	232	mov esi, eax
233	mov edi, eax	233	mov edi, eax
234		234
235	shr esi, 10	235	shr esi, 10
236	add esi, page_tabs	236	add esi, page_tabs
237		237
238	mov ebp, [pg_data.pages_free]	238	mov ebp, [pg_data.pages_free]
239	mov ebx, [page_start]	239	mov ebx, [page_start]
240	mov edx, sys_pgmap	240	mov edx, sys_pgmap
241	@@:	241	@@:
242	xor eax, eax	242	xor eax, eax
243	xchg eax, [esi]	243	xchg eax, [esi]
244	push eax	244	push eax
245	invlpg [edi]	245	invlpg [edi]
246	pop eax	246	pop eax
247		247
248	test eax, 1	248	test eax, 1
249	jz .next	249	jz .next
250		250
251	shr eax, 12	251	shr eax, 12
252	bts [edx], eax	252	bts [edx], eax
253	cmc	253	cmc
254	adc ebp, 0	254	adc ebp, 0
255	shr eax, 3	255	shr eax, 3
256	and eax, -4	256	and eax, -4
257	add eax, edx	257	add eax, edx
258	cmp eax, ebx	258	cmp eax, ebx
259	jae .next	259	jae .next
260		260
261	mov ebx, eax	261	mov ebx, eax
262	.next:	262	.next:
263	add edi, 0x1000	263	add edi, 0x1000
264	add esi, 4	264	add esi, 4
265	dec ecx	265	dec ecx
266	jnz @B	266	jnz @B
267	mov [pg_data.pages_free], ebp	267	mov [pg_data.pages_free], ebp
268	and [pg_data.pg_mutex],0	268	and [pg_data.pg_mutex],0
269	popad	269	popad
270	ret	270	ret
271		271
272	; param	272	; param
273	; eax= base	273	; eax= base
274	; ecx= count	274	; ecx= count
275		275
276	align 4	276	align 4
277	unmap_pages:	277	unmap_pages:
278		278
279	push edi	279	push edi
280		280
281	mov edi, eax	281	mov edi, eax
282	mov edx, eax	282	mov edx, eax
283		283
284	shr edi, 10	284	shr edi, 10
285	add edi, page_tabs	285	add edi, page_tabs
286		286
287	xor eax, eax	287	xor eax, eax
288	@@:	288	@@:
289	stosd	289	stosd
290	invlpg [edx]	290	invlpg [edx]
291	add edx, 0x1000	291	add edx, 0x1000
292	loop @b	292	loop @b
293		293
294	pop edi	294	pop edi
295	ret	295	ret
296		296
297		297
298	align 4	298	align 4
299	proc map_page_table stdcall, lin_addr:dword, phis_addr:dword	299	proc map_page_table stdcall, lin_addr:dword, phis_addr:dword
300	push ebx	300	push ebx
301	mov ebx, [lin_addr]	301	mov ebx, [lin_addr]
302	shr ebx, 22	302	shr ebx, 22
303	mov eax, [phis_addr]	303	mov eax, [phis_addr]
304	and eax, not 0xFFF	304	and eax, not 0xFFF
305	or eax, PG_UW ;+PG_NOCACHE	305	or eax, PG_UW ;+PG_NOCACHE
306	mov dword [master_tab+ebx*4], eax	306	mov dword [master_tab+ebx*4], eax
307	mov eax, [lin_addr]	307	mov eax, [lin_addr]
308	shr eax, 10	308	shr eax, 10
309	add eax, page_tabs	309	add eax, page_tabs
310	invlpg [eax]	310	invlpg [eax]
311	pop ebx	311	pop ebx
312	ret	312	ret
313	endp	313	endp
314		314
315	align 4	315	align 4
316	proc init_LFB	316	proc init_LFB
317	locals	317	locals
318	pg_count dd ?	318	pg_count dd ?
319	endl	319	endl
320		320
321	cmp dword [LFBAddress], -1	321	cmp dword [LFBAddress], -1
322	jne @f	322	jne @f
323	mov [BOOT_VAR+0x901c],byte 2	323	mov [BOOT_VAR+0x901c],byte 2
324	stdcall kernel_alloc, 0x280000	324	stdcall kernel_alloc, 0x280000
325	mov [LFBAddress], eax	325	mov [LFBAddress], eax
326	ret	326	ret
327	@@:	327	@@:
328	test [SCR_MODE],word 0100000000000000b	328	test [SCR_MODE],word 0100000000000000b
329	jnz @f	329	jnz @f
330	mov [BOOT_VAR+0x901c],byte 2	330	mov [BOOT_VAR+0x901c],byte 2
331	ret	331	ret
332	@@:	332	@@:
333	call init_mtrr	333	call init_mtrr
334		334
335	mov edx, LFB_BASE	335	mov edx, LFB_BASE
336	mov esi, [LFBAddress]	336	mov esi, [LFBAddress]
337	mov edi, 0x00800000	337	mov edi, 0x00800000
338	mov dword [exp_lfb+4], edx	338	mov dword [exp_lfb+4], edx
339		339
340	shr edi, 12	340	shr edi, 12
341	mov [pg_count], edi	341	mov [pg_count], edi
342	shr edi, 10	342	shr edi, 10
343		343
344	bt [cpu_caps], CAPS_PSE	344	bt [cpu_caps], CAPS_PSE
345	jnc .map_page_tables	345	jnc .map_page_tables
346	or esi, PG_LARGE+PG_UW	346	or esi, PG_LARGE+PG_UW
347	mov edx, sys_pgdir+(LFB_BASE shr 20)	347	mov edx, sys_pgdir+(LFB_BASE shr 20)
348	@@:	348	@@:
349	mov [edx], esi	349	mov [edx], esi
350	add edx, 4	350	add edx, 4
351	add esi, 0x00400000	351	add esi, 0x00400000
352	dec edi	352	dec edi
353	jnz @B	353	jnz @B
354		354
355	bt [cpu_caps], CAPS_PGE	355	bt [cpu_caps], CAPS_PGE
356	jnc @F	356	jnc @F
357	or dword [sys_pgdir+(LFB_BASE shr 20)], PG_GLOBAL	357	or dword [sys_pgdir+(LFB_BASE shr 20)], PG_GLOBAL
358	@@:	358	@@:
359	mov dword [LFBAddress], LFB_BASE	359	mov dword [LFBAddress], LFB_BASE
360	mov eax, cr3 ;flush TLB	360	mov eax, cr3 ;flush TLB
361	mov cr3, eax	361	mov cr3, eax
362	ret	362	ret
363		363
364	.map_page_tables:	364	.map_page_tables:
365		365
366	@@:	366	@@:
367	call alloc_page	367	call alloc_page
368	stdcall map_page_table, edx, eax	368	stdcall map_page_table, edx, eax
369	add edx, 0x00400000	369	add edx, 0x00400000
370	dec edi	370	dec edi
371	jnz @B	371	jnz @B
372		372
373	mov eax, [LFBAddress]	373	mov eax, [LFBAddress]
374	mov edi, page_tabs + (LFB_BASE shr 10)	374	mov edi, page_tabs + (LFB_BASE shr 10)
375	or eax, PG_UW	375	or eax, PG_UW
376	mov ecx, [pg_count]	376	mov ecx, [pg_count]
377	cld	377	cld
378	@@:	378	@@:
379	stosd	379	stosd
380	add eax, 0x1000	380	add eax, 0x1000
381	dec ecx	381	dec ecx
382	jnz @B	382	jnz @B
383		383
384	mov dword [LFBAddress], LFB_BASE	384	mov dword [LFBAddress], LFB_BASE
385	mov eax, cr3 ;flush TLB	385	mov eax, cr3 ;flush TLB
386	mov cr3, eax	386	mov cr3, eax
387		387
388	ret	388	ret
389	endp	389	endp
390		390
391	align 4	391	align 4
392	proc new_mem_resize stdcall, new_size:dword	392	proc new_mem_resize stdcall, new_size:dword
393		393
394	mov ebx, pg_data.pg_mutex	394	mov ebx, pg_data.pg_mutex
395	call wait_mutex ;ebx	395	call wait_mutex ;ebx
396		396
397	mov edi, [new_size]	397	mov edi, [new_size]
398	add edi,4095	398	add edi,4095
399	and edi,not 4095	399	and edi,not 4095
400	mov [new_size], edi	400	mov [new_size], edi
401		401
402	mov edx,[current_slot]	402	mov edx,[current_slot]
403	cmp [edx+APPDATA.heap_base],0	403	cmp [edx+APPDATA.heap_base],0
404	jne .exit	404	jne .exit
405		405
406	mov esi, [edx+APPDATA.mem_size]	406	mov esi, [edx+APPDATA.mem_size]
407	add esi, 4095	407	add esi, 4095
408	and esi, not 4095	408	and esi, not 4095
409		409
410	cmp edi, esi	410	cmp edi, esi
411	jae .expand	411	jae .expand
412		412
413	shr edi, 12	413	shr edi, 12
414	shr esi, 12	414	shr esi, 12
415	@@:	415	@@:
416	mov eax, [app_page_tabs+edi*4]	416	mov eax, [app_page_tabs+edi*4]
417	test eax, 1	417	test eax, 1
418	jz .next	418	jz .next
419	mov dword [app_page_tabs+edi*4], 2	419	mov dword [app_page_tabs+edi*4], 2
420	mov ebx, edi	420	mov ebx, edi
421	shl ebx, 12	421	shl ebx, 12
422	push eax	422	push eax
423	invlpg [ebx]	423	invlpg [ebx]
424	pop eax	424	pop eax
425	call free_page	425	call free_page
426		426
427	.next: add edi, 1	427	.next: add edi, 1
428	cmp edi, esi	428	cmp edi, esi
429	jb @B	429	jb @B
430		430
431	.update_size:	431	.update_size:
432	mov ebx, [new_size]	432	mov ebx, [new_size]
433	call update_mem_size	433	call update_mem_size
434		434
435	xor eax, eax	435	xor eax, eax
436	dec [pg_data.pg_mutex]	436	dec [pg_data.pg_mutex]
437	ret	437	ret
438	.expand:	438	.expand:
439		439
440	push esi	440	push esi
441	push edi	441	push edi
442		442
443	add edi, 0x3FFFFF	443	add edi, 0x3FFFFF
444	and edi, not(0x3FFFFF)	444	and edi, not(0x3FFFFF)
445	add esi, 0x3FFFFF	445	add esi, 0x3FFFFF
446	and esi, not(0x3FFFFF)	446	and esi, not(0x3FFFFF)
447		447
448	cmp esi, edi	448	cmp esi, edi
449	jae .grow	449	jae .grow
450		450
451	xchg esi, edi	451	xchg esi, edi
452		452
453	@@:	453	@@:
454	call alloc_page	454	call alloc_page
455	test eax, eax	455	test eax, eax
456	jz .exit	456	jz .exit
457		457
458	stdcall map_page_table, edi, eax	458	stdcall map_page_table, edi, eax
459		459
460	push edi	460	push edi
461	shr edi, 10	461	shr edi, 10
462	add edi, page_tabs	462	add edi, page_tabs
463	mov ecx, 1024	463	mov ecx, 1024
464	xor eax, eax	464	xor eax, eax
465	cld	465	cld
466	rep stosd	466	rep stosd
467	pop edi	467	pop edi
468		468
469	add edi, 0x00400000	469	add edi, 0x00400000
470	cmp edi, esi	470	cmp edi, esi
471	jb @B	471	jb @B
472	.grow:	472	.grow:
473	pop edi	473	pop edi
474	pop esi	474	pop esi
475	@@:	475	@@:
476	call alloc_page	476	call alloc_page
477	test eax, eax	477	test eax, eax
478	jz .exit	478	jz .exit
479	stdcall map_page,esi,eax,dword PG_UW	479	stdcall map_page,esi,eax,dword PG_UW
480		480
481	push edi	481	push edi
482	mov edi, esi	482	mov edi, esi
483	xor eax, eax	483	xor eax, eax
484	mov ecx, 1024	484	mov ecx, 1024
485	cld	485	cld
486	rep stosd	486	rep stosd
487	pop edi	487	pop edi
488		488
489	add esi, 0x1000	489	add esi, 0x1000
490	cmp esi, edi	490	cmp esi, edi
491	jb @B	491	jb @B
492		492
493	jmp .update_size	493	jmp .update_size
494	.exit:	494	.exit:
495	xor eax, eax	495	xor eax, eax
496	inc eax	496	inc eax
497	dec [pg_data.pg_mutex]	497	dec [pg_data.pg_mutex]
498	ret	498	ret
499	endp	499	endp
500		500

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/memory.inc – Rev 1030 → 1055