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


$Revision: 536 $
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
align 4
proc alloc_page
 
           pushfd
           cli
           mov ebx, [page_start]
           mov ecx, [page_end]
.l1:
           bsf eax,[ebx];
           jnz .found
           add ebx,4
           cmp ebx, ecx
           jb .l1
           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]
           popfd
           ret
endp
 
align 4
proc alloc_pages stdcall, count:dword
           pushfd
           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
           popfd
           ret
.next:
           inc ecx
           cmp ecx, ebx
           jb .find
           popfd
           xor eax, eax
           ret
.ok:
           sub ecx, edi
           inc ecx
           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
           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
 
; param
;  eax= page base + page flags
;  ebx= liear address
;  ecx= count
 
align 4
commit_pages:
 
           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
           invlpg [edi]
           add edi, edx
           add eax, edx
           inc ebx
           dec ecx
           jnz @B
           mov [pg_data.pg_mutex],ecx
.fail:
           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]
           invlpg [edi]
 
           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
 
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
           invlpg [ebx+std_application_base_address]
           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
 
        .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
           and 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
           and 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
       ;    add edi, new_app_base
           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 ebx, dword [edi+4]
           mov edx, ebx
           add ebx, 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
new_services:
 
           cmp  eax,4
           jle  sys_sheduler
 
           cmp eax, 11
           jb .fail
           ja @f
 
           call init_heap
           mov [esp+36], eax
           ret
@@:
           cmp eax, 12
           ja @f
 
           stdcall user_alloc, ebx
           mov [esp+36], eax
           ret
@@:
           cmp eax, 13
           ja @f
           stdcall user_free, ebx
           mov [esp+36], eax
           ret
@@:
           cmp eax, 14
           ja @f
           cmp ebx, OS_BASE
           jae .fail
           stdcall get_event_ex, ebx, ecx
           mov [esp+36], eax
           ret
@@:
           cmp eax, 15
           ja @f
           mov ecx, [current_slot]
           mov eax, [ecx+APPDATA.fpu_handler]
           mov [ecx+APPDATA.fpu_handler], ebx
           mov [esp+36], eax
           ret
@@:
           cmp eax, 16
           ja @f
 
           test ebx, ebx
           jz .fail
           cmp ebx, OS_BASE
           jae .fail
           stdcall get_service, ebx
           mov [esp+36], eax
           ret
@@:
           cmp eax, 17
           ja @f
           call srv_handlerEx   ;ebx
           mov [esp+36], eax
           ret
@@:
           cmp eax, 18
           ja @f
           mov ecx, [current_slot]
           mov eax, [ecx+APPDATA.sse_handler]
           mov [ecx+APPDATA.sse_handler], ebx
           mov [esp+36], eax
           ret
@@:
           cmp eax, 19
           ja @f
           cmp ebx, OS_BASE
           jae .fail
           stdcall load_library, ebx
           mov [esp+36], eax
           ret
@@:
           cmp     eax, 20
           ja      .fail
           mov     eax, ecx
           call    user_realloc
           mov     [esp+36], eax
           ret
.fail:
           xor eax, eax
           mov [esp+36], eax
           ret
 
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                ;
           push eax
 
           xor edx, edx
           xor eax, eax
           mov ecx, 0x2FF
           wrmsr                ;disable all MTRR
 
           stdcall set_mtrr, dword 0,dword 0,[MEM_AMOUNT],MEM_WB
           stdcall set_mtrr, dword 1,[LFBAddress],[LFBSize],MEM_WC
           xor edx, edx
           xor eax, eax
           mov ecx, 0x204
           mov ebx, 6
@@:
           wrmsr                ;disable unused MTRR
           inc ecx
           wrmsr
           inc ecx
           dec ebx
           jnz @b
 
           wbinvd               ;again invalidate
 
           pop eax
           or eax, 0x800        ;set default memtype to UC
           and al, 0xF0
           mov ecx, 0x2FF
           wrmsr                ;and enable MTRR
 
           mov eax, cr0
           and eax, not 0x60000000
           mov cr0, eax         ; enable caching
.exit:
           ret
endp
 
align 4
proc set_mtrr stdcall, reg:dword,base:dword,size:dword,mem_type:dword
 
           xor edx, edx
           mov eax, [base]
           or eax, [mem_type]
           mov ecx, [reg]
           lea ecx, [0x200+ecx*2]
           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
 
           mov [buf_ptr], eax
 
           mov ebx, [size]
           shr ebx, 12
           push ebx
 
           stdcall alloc_pages, ebx
           pop ecx
 
           test eax, eax
           jz .mm_fail
 
           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+esi]
           add eax, 0x1000
           add ebx, 0x1000
           add edi, 4 
           dec ecx
           jnz @B
 
           mov eax, [buf_ptr]
           ret
.mm_fail:
           stdcall free_kernel_space, [buf_ptr]
           xor eax, eax
.fail:
           ret
endp
 
if 0
     push eax
     push edx
     mov edx, 0x400   ;bochs
     mov al,0xff      ;bochs
     out dx, al       ;bochs
     pop edx
     pop eax
end if

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/memory.inc – Rev 520 → 536