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

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri_pe/core/memory.inc – Rev 897 → 928