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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 889 $
 
 
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
 
proc map_io_mem stdcall, base:dword, size:dword, flags:dword
 
           push edi
 
           mov ecx, [size]
           add ecx, 4095
           and ecx, -4096
           mov [size], ecx
           xor edx, edx
           call @mem_alloc@8
           test eax, eax
           jz .fail
 
           mov edx, eax
           mov edi, eax
           shr edi, 10
           add edi, page_tabs
 
           mov ecx, [size]
           shr ecx, 12
           mov eax, [base]
           and eax, -4096
           or eax, [flags]
@@:
           stosd
           add eax, 0x1000
           loop @B
 
           mov eax, [base]
           and eax, 4095
           add eax, edx
.fail:
           pop edi
           ret
endp
 
; param
;  eax= page base + page flags
;  ebx= linear address
;  ecx= count
 
align 4
commit_pages:
           push edi
           test ecx, ecx
           jz .fail
 
           mov edi, ebx
           mov ebx, pg_data.pg_mutex
           call wait_mutex      ;ebx
 
           mov edx, 0x1000
           mov ebx, edi
           shr ebx, 12
@@:
           mov [page_tabs+ebx*4], eax
          ; push eax
          ; invlpg [edi]
          ; pop eax
           add edi, edx
           add eax, edx
           inc ebx
           dec ecx
           jnz @B
           mov [pg_data.pg_mutex],ecx
.fail:
           pop edi
           ret
 
 
; param
;  eax= base
;  ecx= count
 
align 4
release_pages:
 
           pushad
           mov ebx, pg_data.pg_mutex
           call wait_mutex      ;ebx
 
           mov esi, eax
           mov edi, eax
 
           shr esi, 10
           add esi, page_tabs
 
@@:
           xor eax, eax
           xchg eax, [esi]
           push eax
           invlpg [edi]
           pop eax
.next:
           add edi, 0x1000
           add esi, 4
           dec ecx
           jnz @B
           and [pg_data.pg_mutex],0
           popad
           ret
 
; param
;  eax= base
;  ecx= count
 
align 4
unmap_pages:
 
           push edi
 
           mov edi, eax
           mov edx, eax
 
           shr edi, 10
           add edi, page_tabs
 
           xor eax, eax
@@:
           stosd
           invlpg [edx]
           add edx, 0x1000
           loop @b
 
           pop edi
           ret
 
 
align 4
proc map_page_table stdcall, lin_addr:dword, phis_addr:dword
           push ebx
           mov ebx, [lin_addr]
           shr ebx, 22
           mov eax, [phis_addr]
           and eax, not 0xFFF
           or eax, PG_UW          ;+PG_NOCACHE
           mov dword [master_tab+ebx*4], eax
           mov eax, [lin_addr]
           shr eax, 10
           add eax, page_tabs
           invlpg [eax]
           pop ebx
           ret
endp
 
align 4
proc init_LFB
           locals
             pg_count dd ?
           endl
 
           cmp dword [LFBAddress], -1
           jne @f
           mov [BOOT_VAR+0x901c],byte 2
           mov ecx, 0x280000
           mov edx, PG_SW
           call @mem_alloc@8
           mov [LFBAddress], eax
           ret
@@:
           test [SCR_MODE],word 0100000000000000b
           jnz @f
           mov [BOOT_VAR+0x901c],byte 2
           ret
@@:
           call init_mtrr
 
           mov eax, [LFBAddress]
           or eax, PG_LARGE+PG_UW
           mov [_sys_pdbr+(LFB_BASE shr 20)], eax
           add eax, 0x00400000
           mov [_sys_pdbr+4+(LFB_BASE shr 20)], eax
 
           mov dword [exp_lfb+4], LFB_BASE
 
           bt [cpu_caps], CAPS_PGE
           jnc @F
           or dword [_sys_pdbr+(LFB_BASE shr 20)], PG_GLOBAL
@@:
           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 ecx, [app_page_tabs+edi*4]
           test ecx, 1
           jz .next
 
           mov dword [app_page_tabs+edi*4], 2
           mov ebx, edi
           shl ebx, 12
           invlpg [ebx]
           call @core_free@4
.next:
           add edi, 1
           cmp edi, esi
           jb @B
 
.update_size:
           mov     ebx, [new_size]
           call    update_mem_size
 
           xor eax, eax
           dec [pg_data.pg_mutex]
           ret
.expand:
 
           push esi
           push edi
 
           add edi, 0x3FFFFF
           and edi, not(0x3FFFFF)
           add esi, 0x3FFFFF
           and esi, not(0x3FFFFF)
 
           cmp esi, edi
           jae .grow
 
           xchg esi, edi
 
@@:
           call _alloc_page
           test eax, eax
           jz .exit
 
           stdcall map_page_table, edi, eax
 
           push edi
           shr edi, 10
           add edi, page_tabs
           mov ecx, 1024
           xor eax, eax
           cld
           rep stosd
           pop edi
 
           add edi, 0x00400000
           cmp edi, esi
           jb @B
.grow:
           pop edi
           pop esi
@@:
           call _alloc_page
           test eax, eax
           jz .exit
           stdcall map_page,esi,eax,dword PG_UW
 
           push edi
           mov edi, esi
           xor eax, eax
           mov ecx, 1024
           cld
           rep stosd
           pop edi
 
           add esi, 0x1000
           cmp esi, edi
           jb  @B
 
           jmp .update_size
.exit:
           xor eax, eax
           inc eax
           dec [pg_data.pg_mutex]
           ret
endp
 
update_mem_size:
; in: edx = slot base
;     ebx = new memory size
; destroys eax,ecx,edx
 
           mov    [APPDATA.mem_size+edx],ebx
;search threads and update
;application memory size infomation
           mov    ecx,[APPDATA.dir_table+edx]
           mov    eax,2
 
.search_threads:
;eax = current slot
;ebx = new memory size
;ecx = page directory
           cmp    eax,[TASK_COUNT]
           jg     .search_threads_end
           mov    edx,eax
           shl    edx,5
           cmp    word [CURRENT_TASK+edx+TASKDATA.state],9 ;if slot empty?
           jz     .search_threads_next
           shl    edx,3
           cmp    [SLOT_BASE+edx+APPDATA.dir_table],ecx     ;if it is our thread?
           jnz    .search_threads_next
           mov    [SLOT_BASE+edx+APPDATA.mem_size],ebx     ;update memory size
.search_threads_next:
           inc    eax
           jmp    .search_threads
.search_threads_end:
           ret
 
; param
;  eax= linear address
;
; retval
;  eax= phisical page address
 
align 4
get_pg_addr:
           shr eax, 12
           mov eax, [page_tabs+eax*4]
           and eax, 0xFFFFF000
           ret
 
 
align 4
proc page_fault_handler
 
        test    byte [esp+12+2], 2
        jnz     v86_page_fault
 
        .err_code equ ebp+32
        .err_addr equ ebp-4
 
           pushad
           mov ebp, esp
           mov eax, cr2
           push eax
 
           mov ax, app_data
           mov ds, ax
           mov es, ax
 
           inc [pg_data.pages_faults]
 
           mov ebx, [.err_addr]
           mov eax, [.err_code]
 
           cmp ebx, HEAP_BASE
           jb .user_space      ;ñòðàíèöà â ïàìÿòè ïðèëîæåíèÿ ;
 
           cmp ebx, LFB_BASE
           jb  .kernel_heap
 
           cmp ebx, page_tabs
           jb .lfb
 
           cmp ebx, heap_tabs
           jb .user_tabs
 
           cmp ebx, OS_BASE
           jb .heap_tab
 
 
         ;  cmp ebx, kernel_tabs
         ;  jb .alloc;.app_tabs ;òàáëèöû ñòðàíèö ïðèëîæåíèÿ ;
                               ;ïðîñòî ñîçäàäèì îäíó
 
 
 
.lfb:
           shr ebx, 22
           mov edx, [_sys_pdbr + ebx*4]
           mov [master_tab + ebx*4], edx
           jmp .exit
 
.user_tabs:
           shr ebx, 12
           and ebx, 0x3FF
           mov edx, [master_tab + ebx*4]
           test edx, PG_MAP
           jnz .fail
 
           call _alloc_page
           test eax, eax
           jz .fail
 
           lea edx, [eax + PG_UW]
           lea edi, [eax + OS_BASE]
           mov ecx, 1024
           xor eax, eax
           cld
           rep stosd
 
           mov [master_tab + ebx*4], edx
           jmp .exit
 
.heap_tab:
           shr ebx, 12
           and ebx, 0x3FF
           mov edx, [master_tab + ebx*4]
           test edx, PG_MAP
           jz .check_ptab      ;òàáëèöà ñòðàíèö íå ñîçäàíà
 
           jmp .fail
 
align 4
.kernel_heap:
 
           shr ebx, 22
           mov edx, [master_tab + ebx*4]
 
           test edx, PG_MAP
           jz .check_ptab      ;òàáëèöà ñòðàíèö íå ñîçäàíà
 
           jmp .exit
 
.check_ptab:
           mov edx, [_sys_pdbr + ebx*4]
           test edx, PG_MAP
           jnz @F
 
           xor ecx, ecx
           call @core_alloc@4
           test eax, eax
           jz .fail
 
           lea edx, [eax + PG_UW]
           lea edi, [eax + OS_BASE]
           mov ecx, 1024
           xor eax, eax
           cld
           rep stosd
 
           mov [_sys_pdbr + ebx*4], edx
@@:
           mov [master_tab + ebx*4], edx
           jmp .exit
 
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
 
 
;íå îáðàáàòûâàåì. Îøèáêà
 
.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
           lea ecx, [esi+0x1000]
           xor edx, edx
           call @mem_alloc@8
           mov ecx, eax
           pop 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]
           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, [_mem_amount]
           shr eax, 12
           mov [ebx], eax
           shl eax, 12
           mov [esp+36], eax
           call _get_free_mem
           mov [ebx+4], eax
           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      @F
           mov     eax, ecx
           call    user_realloc
           mov     [esp+36], eax
           ret
@@:
           cmp eax, 21                     ;for test purposes only
           ja @f                           ;will be removed soon
           cmp ebx, OS_BASE
           jae .fail
 
 
 
 
 
 
           mov ecx, ebx
 
 
 
 
 
 
 
           call @load_pe_driver@4
           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
 
           mov eax, [_mem_amount]
; round eax up to next power of 2
           dec eax
           bsr ecx, eax
           mov eax, 2
           shl eax, cl
           stdcall set_mtrr, edx,edx,eax,MEM_WB
           stdcall set_mtrr, 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 ecx, [size]
           test ecx, 4095
           jnz .fail
 
           add ecx, ecx
           xor edx, edx
           call @mem_alloc@8
           test eax, eax
           mov [buf_ptr], eax
           jz .fail
 
           push ebx
 
           xor ecx, ecx
           mov edx, [size]
           shr edx, 12
           mov ebx, edx
           dec edx
           bsr ecx, edx
           inc ecx
 
           call @core_alloc@4
           test eax, eax
           jz .mm_fail
 
           or eax,  [flags]
           mov edx, [buf_ptr]
           lea ecx, [ebx*4]
           shr edx, 10
@@:
           mov [page_tabs+edx], eax
           mov [page_tabs+edx+ecx], eax
           add eax, 0x1000
           add edx, 4
           dec ebx
           jnz @B
 
           mov eax, [buf_ptr]
           pop ebx
           ret
.mm_fail:
           ;stdcall free_kernel_space, [buf_ptr]
           pop ebx
           xor eax, eax
.fail:
           ret
endp
 
 
align 4
_balloc:   ; gcc fastcall
@balloc@4:
 
 
           mov eax, [_pg_balloc]
           add ecx, 4095
           and ecx, -4096
           add ecx, eax
           mov [_pg_balloc], ecx
           add eax, OS_BASE
           ret

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

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri_pe/core/memory.inc – Rev 888 → 889