WebSVN – Kolibri OS – Diff – /kernel/branches/flat_kernel/core/memory.inc


$Revision: 448 $
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; 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
@@:
           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,dword PG_UW
           mov ebx, [ofs]
           shr ebx, 22
           mov esi, [ipc_pdir]
           mov edi, [ipc_ptab]
           mov eax, [esi+ebx*4]
           and eax, 0xFFFFF000
           test eax, eax
           jz .exit
           stdcall map_page,edi,eax,dword 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
           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
 
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
           jna .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 ?
           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
 
           stdcall map_mem, [ipc_tmp], [SLOT_BASE+eax+0xB8],\
                             edi, esi
 
           mov edi, [dst_offset]
           add edi, [ipc_tmp]
           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
           mov edi, [dst_offset]
           add edi, [ipc_tmp]
           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:
           popf
           xor eax, eax
           ret
.no_pid:
           popf
           mov  eax, 4
           ret
.no_ipc_area:
           popf
           xor eax, eax
           inc eax
           ret
.ipc_blocked:
           popf
           mov  eax, 2
           ret
.buffer_overflow:
           popf
           mov  eax, 3
           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 strncmp stdcall, str1:dword, str2:dword, count:dword
 
          mov ecx,[count]
          jecxz .end
 
          mov ebx,ecx
 
          mov edi,[str1]
          mov esi,edi
          xor eax,eax
          repne scasb
          neg ecx             ; cx = count - strlen
          add ecx,ebx         ; strlen + count - strlen
 
.okay:
          mov edi,esi
          mov esi,[str2]
          repe cmpsb
          mov al,[esi-1]
          xor ecx,ecx
 
          cmp al,[edi-1]
          ja .str2_big
          je .end
 
.str1_big:
          sub ecx,2
 
.str2_big:
          not ecx
.end:
          mov eax,ecx
          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
k_strrchr:
        push eax
        xor eax,eax
        or  ecx,-1
        repne scasb
        add ecx,1
        neg ecx
        sub edi,1
        pop eax
        std
        repne scasb
        cld
        add edi,1
 
        cmp [edi],al
        jne @F
        mov eax,edi
        ret
@@:
        xor eax,eax
        ret
 
align 4
proc k_strncpy stdcall, dest:dword, src:dword, maxlen:dword
        mov eax, [dest]
        mov esi, [src]
        mov ecx, [maxlen]
        test eax, eax
        jz .L9
        test esi, esi
        jz .L9
        test ecx, ecx
        jz .L9
 
        sub  esi, eax
        jmp .L1
 
align 4
.L2:
        mov edx, [esi+eax]
        mov [eax], dl
        test dl, dl
        jz .L7
 
        mov [eax+1], dh
        test dh, dh
        jz .L6
 
        shr edx, 16
        mov [eax+2],dl
        test dl, dl
        jz .L5
 
        mov [eax+3], dh
        test dh, dh
        jz .L4
        add eax, 4
.L1:
        sub ecx, 4
        jae .L2
 
        add ecx, 4
        jz .L9
 
        mov dl, [eax+esi]
        mov [eax], dl
        test dl, dl
        jz .L3
 
        inc eax
        dec ecx
        jz .L9
 
        mov dl, [eax+esi]
        mov [eax], dl
        test dl, dl
        jz .L3
 
        inc eax
        dec ecx
        jz .L9
 
        mov dl, [eax+esi]
        mov [eax], dl
        test dl, dl
        jz .L3
 
        inc eax
        jmp .L9
 
.L4:    dec ecx
        inc eax
 
.L5:    dec ecx
        inc eax
 
.L6:    dec ecx
        inc eax
.L7:
        add ecx,3
        jz .L9
.L8:
        mov byte [ecx+eax], 0
.L3:
        dec ecx
        jnz .L8
.L9:
	ret
endp
 
if 0
 
magic equ 0xfefefeff
 
k_strlen:
        mov eax,[esp+4]
        mov edx, 3
 
        and edx, eax
        jz .L1
        jp .L0
 
        cmp dh, byte [eax]
        je .L2
 
        inc eax
        cmp dh, byte [eax]
 
        je .L2
 
        inc eax
        xor edx, 2
 
        jz .L1
.L0:
        cmp dh, [eax]
        je .L2
 
        inc eax
        xor edx, edx
 
.L1:
        mov ecx, [eax]
        add eax, 4
 
        sub edx, ecx
        add ecx, magic
 
        dec edx
        jnc .L3
 
        xor edx, ecx
        and edx, not magic
        jne .L3
 
        mov ecx, [eax]
        add eax, 4
 
        sub edx, ecx
        add ecx, magic
        dec edx
        jnc .L3
 
        xor edx, ecx
        and edx, not magic
        jne .L3
 
        mov ecx, [eax]
        add eax, 4
 
        sub edx, ecx
        add ecx, magic
 
        dec edx
        jnc .L3
 
        xor edx, ecx
 
        and edx, not magic
        jne .L3
 
        mov ecx, [eax]
        add eax, 4
 
        sub edx, ecx
        add ecx, magic
 
        dec edx
        jnc .L3
 
        xor edx, ecx
 
        and edx, not magic
        je .L1
 
.L3:    sub eax ,4
        sub ecx, magic
 
        cmp cl, 0
        jz .L2
 
        inc eax
        test ch, ch
        jz .L2
 
        shr ecx, 16
        inc eax
 
        cmp cl,0
        jz .L2
 
        inc eax
 
.L2:
        sub eax, [esp+4]
	ret
 
end if
 
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 444	Rev 453
1	$Revision: 431 $	1	$Revision: 448 $
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	mov ebx, sys_pgmap	-
115	bts [ebx], eax ;that's all!	114	bts dword [sys_pgmap], eax ;that's all!
116	cmc	115	cmc
117	adc [pg_data.pages_free], 0	116	adc [pg_data.pages_free], 0
118	shr eax, 3	117	shr eax, 3
119	and eax, not 3 ;dword offset from page_map	118	and eax, not 3 ;dword offset from page_map
120	add eax, ebx	119	add eax, sys_pgmap
121	cmp [page_start], eax	120	cmp [page_start], eax
122	ja @f	121	ja @f
123	popfd	122	popfd
124	ret	123	ret
125	@@:	124	@@:
126	mov [page_start], eax	125	mov [page_start], eax
127	popfd	126	popfd
128	ret	127	ret
129	endp	128	endp
130		129
131	; param	130	; param
132	; eax= page base + page flags	131	; eax= page base + page flags
133	; ebx= liear address	132	; ebx= liear address
134	; ecx= count	133	; ecx= count
135		134
136	align 4	135	align 4
137	commit_pages:	136	commit_pages:
138		137
139	test ecx, ecx	138	test ecx, ecx
140	jz .fail	139	jz .fail
141		140
142	mov edi, ebx	141	mov edi, ebx
143	mov ebx, pg_data.pg_mutex	142	mov ebx, pg_data.pg_mutex
144	call wait_mutex ;ebx	143	call wait_mutex ;ebx
145		144
146	mov edx, 0x1000	145	mov edx, 0x1000
147	mov ebx, edi	146	mov ebx, edi
148	shr ebx, 12	147	shr ebx, 12
149	@@:	148	@@:
150	mov [page_tabs+ebx*4], eax	149	mov [page_tabs+ebx*4], eax
151	invlpg [edi]	150	invlpg [edi]
152	add edi, edx	151	add edi, edx
153	add eax, edx	152	add eax, edx
154	inc ebx	153	inc ebx
155	dec ecx	154	dec ecx
156	jnz @B	155	jnz @B
157	mov [pg_data.pg_mutex],ecx	156	mov [pg_data.pg_mutex],ecx
158	.fail:	157	.fail:
159	ret	158	ret
160		159
161		160
162	; param	161	; param
163	; eax= base	162	; eax= base
164	; ecx= count	163	; ecx= count
165		164
166	align 4	165	align 4
167	release_pages:	166	release_pages:
168		167
169	pushad	168	pushad
170	mov ebx, pg_data.pg_mutex	169	mov ebx, pg_data.pg_mutex
171	call wait_mutex ;ebx	170	call wait_mutex ;ebx
172		171
173	mov esi, eax	172	mov esi, eax
174	mov edi, eax	173	mov edi, eax
175		174
176	shr esi, 10	175	shr esi, 10
177	add esi, page_tabs	176	add esi, page_tabs
178		177
179	mov ebp, [pg_data.pages_free]	178	mov ebp, [pg_data.pages_free]
180	mov ebx, [page_start]	179	mov ebx, [page_start]
181	mov edx, sys_pgmap	180	mov edx, sys_pgmap
182	@@:	181	@@:
183	xor eax, eax	182	xor eax, eax
184	xchg eax, [esi]	183	xchg eax, [esi]
185	invlpg [edi]	184	invlpg [edi]
186		185
187	test eax, 1	186	test eax, 1
188	jz .next	187	jz .next
189		188
190	shr eax, 12	189	shr eax, 12
191	bts [edx], eax	190	bts [edx], eax
192	cmc	191	cmc
193	adc ebp, 0	192	adc ebp, 0
194	shr eax, 3	193	shr eax, 3
195	and eax, -4	194	and eax, -4
196	add eax, edx	195	add eax, edx
197	cmp eax, ebx	196	cmp eax, ebx
198	jae .next	197	jae .next
199		198
200	mov ebx, eax	199	mov ebx, eax
201	.next:	200	.next:
202	add edi, 0x1000	201	add edi, 0x1000
203	add esi, 4	202	add esi, 4
204	dec ecx	203	dec ecx
205	jnz @B	204	jnz @B
206	mov [pg_data.pages_free], ebp	205	mov [pg_data.pages_free], ebp
207	and [pg_data.pg_mutex],0	206	and [pg_data.pg_mutex],0
208	popad	207	popad
209	ret	208	ret
210		209
211	align 4	210	align 4
212	proc map_page_table stdcall, lin_addr:dword, phis_addr:dword	211	proc map_page_table stdcall, lin_addr:dword, phis_addr:dword
213	push ebx	212	push ebx
214	mov ebx, [lin_addr]	213	mov ebx, [lin_addr]
215	shr ebx, 22	214	shr ebx, 22
216	mov eax, [phis_addr]	215	mov eax, [phis_addr]
217	and eax, not 0xFFF	216	and eax, not 0xFFF
218	or eax, PG_UW ;+PG_NOCACHE	217	or eax, PG_UW ;+PG_NOCACHE
219	mov dword [master_tab+ebx*4], eax	218	mov dword [master_tab+ebx*4], eax
220	mov eax, [lin_addr]	219	mov eax, [lin_addr]
221	shr eax, 10	220	shr eax, 10
222	add eax, page_tabs	221	add eax, page_tabs
223	invlpg [eax]	222	invlpg [eax]
224	pop ebx	223	pop ebx
225	ret	224	ret
226	endp	225	endp
227		226
228	align 4	227	align 4
229	proc init_LFB	228	proc init_LFB
230	locals	229	locals
231	pg_count dd ?	230	pg_count dd ?
232	endl	231	endl
233		232
234	cmp dword [LFBAddress], -1	233	cmp dword [LFBAddress], -1
235	jne @f	234	jne @f
236	mov [BOOT_VAR+0x901c],byte 2	235	mov [BOOT_VAR+0x901c],byte 2
237	stdcall kernel_alloc, 0x280000	236	stdcall kernel_alloc, 0x280000
238	mov [LFBAddress], eax	237	mov [LFBAddress], eax
239	ret	238	ret
240	@@:	239	@@:
241	test [SCR_MODE],word 0100000000000000b	240	test [SCR_MODE],word 0100000000000000b
242	jnz @f	241	jnz @f
243	mov [BOOT_VAR+0x901c],byte 2	242	mov [BOOT_VAR+0x901c],byte 2
244	ret	243	ret
245	@@:	244	@@:
246	mov edx, LFB_BASE	245	mov edx, LFB_BASE
247	mov esi, [LFBAddress]	246	mov esi, [LFBAddress]
248	mov edi, 0x00800000	247	mov edi, 0x00800000
249	mov dword [exp_lfb+4], edx	248	mov dword [exp_lfb+4], edx
250		249
251	shr edi, 12	250	shr edi, 12
252	mov [pg_count], edi	251	mov [pg_count], edi
253	shr edi, 10	252	shr edi, 10
254		253
255	bt [cpu_caps], CAPS_PSE	254	bt [cpu_caps], CAPS_PSE
256	jnc .map_page_tables	255	jnc .map_page_tables
257	or esi, PG_LARGE+PG_UW	256	or esi, PG_LARGE+PG_UW
258	mov edx, sys_pgdir+(LFB_BASE shr 20)	257	mov edx, sys_pgdir+(LFB_BASE shr 20)
259	@@:	258	@@:
260	mov [edx], esi	259	mov [edx], esi
261	add edx, 4	260	add edx, 4
262	add esi, 0x00400000	261	add esi, 0x00400000
263	dec edi	262	dec edi
264	jnz @B	263	jnz @B
265		264
266	bt [cpu_caps], CAPS_PGE	265	bt [cpu_caps], CAPS_PGE
267	jnc @F	266	jnc @F
268	or dword [sys_pgdir+(LFB_BASE shr 20)], PG_GLOBAL	267	or dword [sys_pgdir+(LFB_BASE shr 20)], PG_GLOBAL
269	@@:	268	@@:
270	mov dword [LFBAddress], LFB_BASE	269	mov dword [LFBAddress], LFB_BASE
271	mov eax, cr3 ;flush TLB	270	mov eax, cr3 ;flush TLB
272	mov cr3, eax	271	mov cr3, eax
273	ret	272	ret
274		273
275	.map_page_tables:	274	.map_page_tables:
276		275
277	@@:	276	@@:
278	call alloc_page	277	call alloc_page
279	stdcall map_page_table, edx, eax	278	stdcall map_page_table, edx, eax
280	add edx, 0x00400000	279	add edx, 0x00400000
281	dec edi	280	dec edi
282	jnz @B	281	jnz @B
283		282
284	mov eax, [LFBAddress]	283	mov eax, [LFBAddress]
285	mov edi, page_tabs + (LFB_BASE shr 10)	284	mov edi, page_tabs + (LFB_BASE shr 10)
286	or eax, PG_UW	285	or eax, PG_UW
287	mov ecx, [pg_count]	286	mov ecx, [pg_count]
288	cld	287	cld
289	@@:	288	@@:
290	stosd	289	stosd
291	add eax, 0x1000	290	add eax, 0x1000
292	dec ecx	291	dec ecx
293	jnz @B	292	jnz @B
294		293
295	mov dword [LFBAddress], LFB_BASE	294	mov dword [LFBAddress], LFB_BASE
296	mov eax, cr3 ;flush TLB	295	mov eax, cr3 ;flush TLB
297	mov cr3, eax	296	mov cr3, eax
298		297
299	ret	298	ret
300	endp	299	endp
301		300
302	align 4	301	align 4
303	proc new_mem_resize stdcall, new_size:dword	302	proc new_mem_resize stdcall, new_size:dword
304		303
305	mov ebx, pg_data.pg_mutex	304	mov ebx, pg_data.pg_mutex
306	call wait_mutex ;ebx	305	call wait_mutex ;ebx
307		306
308	mov edi, [new_size]	307	mov edi, [new_size]
309	add edi,4095	308	add edi,4095
310	and edi,not 4095	309	and edi,not 4095
311	mov [new_size], edi	310	mov [new_size], edi
312		311
313	mov edx,[current_slot]	312	mov edx,[current_slot]
314	cmp [edx+APPDATA.heap_base],0	313	cmp [edx+APPDATA.heap_base],0
315	jne .exit	314	jne .exit
316		315
317	mov esi, [edx+APPDATA.mem_size]	316	mov esi, [edx+APPDATA.mem_size]
318	add esi, 4095	317	add esi, 4095
319	and esi, not 4095	318	and esi, not 4095
320		319
321	cmp edi, esi	320	cmp edi, esi
322	jae .expand	321	jae .expand
323		322
324	shr edi, 12	323	shr edi, 12
325	shr esi, 12	324	shr esi, 12
326	@@:	325	@@:
327	mov eax, [app_page_tabs+edi*4]	326	mov eax, [app_page_tabs+edi*4]
328	test eax, 1	327	test eax, 1
329	jz .next	328	jz .next
330	mov dword [app_page_tabs+edi*4], 2	329	mov dword [app_page_tabs+edi*4], 2
331	mov ebx, edi	330	mov ebx, edi
332	shl ebx, 12	331	shl ebx, 12
333	invlpg [ebx+std_application_base_address]	332	invlpg [ebx+std_application_base_address]
334	call free_page	333	call free_page
335		334
336	.next: add edi, 1	335	.next: add edi, 1
337	cmp edi, esi	336	cmp edi, esi
338	jb @B	337	jb @B
339		338
340	.update_size:	339	.update_size:
341	mov ebx, [new_size]	340	mov ebx, [new_size]
342	call update_mem_size	341	call update_mem_size
343		342
344	xor eax, eax	343	xor eax, eax
345	dec [pg_data.pg_mutex]	344	dec [pg_data.pg_mutex]
346	ret	345	ret
347	.expand:	346	.expand:
348		347
349	push esi	348	push esi
350	push edi	349	push edi
351		350
352	add edi, 0x3FFFFF	351	add edi, 0x3FFFFF
353	and edi, not(0x3FFFFF)	352	and edi, not(0x3FFFFF)
354	add esi, 0x3FFFFF	353	add esi, 0x3FFFFF
355	and esi, not(0x3FFFFF)	354	and esi, not(0x3FFFFF)
356		355
357	cmp esi, edi	356	cmp esi, edi
358	jae .grow	357	jae .grow
359		358
360	xchg esi, edi	359	xchg esi, edi
361		360
362	@@:	361	@@:
363	call alloc_page	362	call alloc_page
364	test eax, eax	363	test eax, eax
365	jz .exit	364	jz .exit
366		365
367	stdcall map_page_table, edi, eax	366	stdcall map_page_table, edi, eax
368		367
369	push edi	368	push edi
370	shr edi, 10	369	shr edi, 10
371	add edi, page_tabs	370	add edi, page_tabs
372	mov ecx, 1024	371	mov ecx, 1024
373	xor eax, eax	372	xor eax, eax
374	cld	373	cld
375	rep stosd	374	rep stosd
376	pop edi	375	pop edi
377		376
378	add edi, 0x00400000	377	add edi, 0x00400000
379	cmp edi, esi	378	cmp edi, esi
380	jb @B	379	jb @B
381	.grow:	380	.grow:
382	pop edi	381	pop edi
383	pop esi	382	pop esi
384	@@:	383	@@:
385	call alloc_page	384	call alloc_page
386	test eax, eax	385	test eax, eax
387	jz .exit	386	jz .exit
388	stdcall map_page,esi,eax,dword PG_UW	387	stdcall map_page,esi,eax,dword PG_UW
389		388
390	push edi	389	push edi
391	mov edi, esi	390	mov edi, esi
392	xor eax, eax	391	xor eax, eax
393	mov ecx, 1024	392	mov ecx, 1024
394	cld	393	cld
395	rep stosd	394	rep stosd
396	pop edi	395	pop edi
397		396
398	add esi, 0x1000	397	add esi, 0x1000
399	cmp esi, edi	398	cmp esi, edi
400	jb @B	399	jb @B
401		400
402	jmp .update_size	401	jmp .update_size
403	.exit:	402	.exit:
404	xor eax, eax	403	xor eax, eax
405	inc eax	404	inc eax
406	dec [pg_data.pg_mutex]	405	dec [pg_data.pg_mutex]
407	ret	406	ret
408	endp	407	endp
409		408
410	update_mem_size:	409	update_mem_size:
411	; in: edx = slot base	410	; in: edx = slot base
412	; ebx = new memory size	411	; ebx = new memory size
413	; destroys eax,ecx,edx	412	; destroys eax,ecx,edx
414		413
415	mov [APPDATA.mem_size+edx],ebx	414	mov [APPDATA.mem_size+edx],ebx
416	;search threads and update	415	;search threads and update
417	;application memory size infomation	416	;application memory size infomation
418	mov ecx,[APPDATA.dir_table+edx]	417	mov ecx,[APPDATA.dir_table+edx]
419	mov eax,2	418	mov eax,2
420		419
421	.search_threads:	420	.search_threads:
422	;eax = current slot	421	;eax = current slot
423	;ebx = new memory size	422	;ebx = new memory size
424	;ecx = page directory	423	;ecx = page directory
425	cmp eax,[TASK_COUNT]	424	cmp eax,[TASK_COUNT]
426	jg .search_threads_end	425	jg .search_threads_end
427	mov edx,eax	426	mov edx,eax
428	shl edx,5	427	shl edx,5
429	cmp word [CURRENT_TASK+edx+TASKDATA.state],9 ;if slot empty?	428	cmp word [CURRENT_TASK+edx+TASKDATA.state],9 ;if slot empty?
430	jz .search_threads_next	429	jz .search_threads_next
431	shl edx,3	430	shl edx,3
432	cmp [SLOT_BASE+edx+APPDATA.dir_table],ecx ;if it is our thread?	431	cmp [SLOT_BASE+edx+APPDATA.dir_table],ecx ;if it is our thread?
433	jnz .search_threads_next	432	jnz .search_threads_next
434	mov [SLOT_BASE+edx+APPDATA.mem_size],ebx ;update memory size	433	mov [SLOT_BASE+edx+APPDATA.mem_size],ebx ;update memory size
435	.search_threads_next:	434	.search_threads_next:
436	inc eax	435	inc eax
437	jmp .search_threads	436	jmp .search_threads
438	.search_threads_end:	437	.search_threads_end:
439	ret	438	ret
440		439
441	; param	440	; param
442	; eax= linear address	441	; eax= linear address
443	;	442	;
444	; retval	443	; retval
445	; eax= phisical page address	444	; eax= phisical page address
446		445
447	align 4	446	align 4
448	get_pg_addr:	447	get_pg_addr:
449	shr eax, 12	448	shr eax, 12
450	mov eax, [page_tabs+eax*4]	449	mov eax, [page_tabs+eax*4]
451	and eax, 0xFFFFF000	450	and eax, 0xFFFFF000
452	ret	451	ret
453		452
454		453
455	align 4	454	align 4
456	proc page_fault_handler	455	proc page_fault_handler
457		456
458	.err_code equ ebp+32	457	.err_code equ ebp+32
459	.err_addr equ ebp-4	458	.err_addr equ ebp-4
460		459
461	pushad	460	pushad
462	mov ebp, esp	461	mov ebp, esp
463	mov eax, cr2	462	mov eax, cr2
464	push eax	463	push eax
465		464
466	mov ax, app_data	465	mov ax, app_data
467	mov ds, ax	466	mov ds, ax
468	mov es, ax	467	mov es, ax
469		468
470	inc [pg_data.pages_faults]	469	inc [pg_data.pages_faults]
471		470
472	push eax	471	push eax
473	push edx	472	push edx
474	mov edx, 0x400 ;bochs	473	mov edx, 0x400 ;bochs
475	mov al,0xff ;bochs	474	mov al,0xff ;bochs
476	out dx, al ;bochs	475	out dx, al ;bochs
477	pop edx	476	pop edx
478	pop eax	477	pop eax
479		478
480	mov ebx, [.err_addr]	479	mov ebx, [.err_addr]
481	mov eax, [.err_code]	480	mov eax, [.err_code]
482		481
483	cmp ebx, OS_BASE	482	cmp ebx, OS_BASE
484	jb .user_space ;ñòðàíèöà â ïàìÿòè ïðèëîæåíèÿ ;	483	jb .user_space ;ñòðàíèöà â ïàìÿòè ïðèëîæåíèÿ ;
485		484
486	cmp ebx, page_tabs	485	cmp ebx, page_tabs
487	jb .kernel_space ;ñòðàíèöà â ïàìÿòè ÿäðà	486	jb .kernel_space ;ñòðàíèöà â ïàìÿòè ÿäðà
488		487
489	cmp ebx, kernel_tabs	488	cmp ebx, kernel_tabs
490	jb .alloc;.app_tabs ;òàáëèöû ñòðàíèö ïðèëîæåíèÿ ;	489	jb .alloc;.app_tabs ;òàáëèöû ñòðàíèö ïðèëîæåíèÿ ;
491	;ïðîñòî ñîçäàäèì îäíó	490	;ïðîñòî ñîçäàäèì îäíó
492		491
493	cmp ebx, LFB_BASE	492	cmp ebx, LFB_BASE
494	jb .core_tabs ;òàáëèöû ñòðàíèö ÿäðà	493	jb .core_tabs ;òàáëèöû ñòðàíèö ÿäðà
495	;Îøèáêà	494	;Îøèáêà
496	.lfb:	495	.lfb:
497	;îáëàñòü LFB	496	;îáëàñòü LFB
498	;Îøèáêà	497	;Îøèáêà
499	jmp .fail	498	jmp .fail
500		499

Subversion Repositories Kolibri OS

(root)/kernel/branches/flat_kernel/core/memory.inc – Rev 444 → 453