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


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/memory.inc – Rev 593 → 659