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


tmp_page_tab      equ 0x01000000
 
align 4
proc mem_test
           mov eax, cr0
           or eax, (CR0_CD+CR0_NW);disable caching
           mov cr0, eax
           wbinvd                 ;invalidate cache
 
           xor     edi, edi
           mov ebx, 'TEST'
@@:
           add edi, 0x400000
           xchg ebx, dword [edi]
           cmp dword [edi], 'TEST'
           xchg ebx, dword [edi]
           je @b
 
           and eax, not (CR0_CD+CR0_NW)
           mov cr0, eax
           mov eax, edi
           ret
endp
 
align 4
proc init_memEx
           xor eax, eax
           mov edi, sys_pgdir
           mov ecx, 2048
           rep stosd
 
           bt [cpu_caps], CAPS_PSE
           jnc .no_PSE
 
           mov ebx, cr4
           or ebx, CR4_PSE
           mov eax, PG_LARGE+PG_SW
           bt [cpu_caps], CAPS_PGE
           jnc @F
           or eax, PG_GLOBAL
           or ebx, CR4_PGE
 
@@:
           mov cr4, ebx
 
           mov dword [sys_pgdir], eax
           add eax, 0x00400000
           mov dword [sys_pgdir+4], eax
           add eax, 0x00400000
           mov dword [sys_pgdir+8], eax
           add eax, 0x00400000
           mov dword [sys_pgdir+12], eax
 
           mov dword [sys_pgdir+0x600], sys_master_tab+PG_SW
           mov dword [sys_master_tab+0x600], sys_master_tab+PG_SW
 
           mov ecx, [pg_data.kernel_tables]
           sub ecx, 4
           mov eax, tmp_page_tab+PG_SW
           mov edi, sys_pgdir+16
           mov esi, sys_master_tab+16
 
           jmp .map_kernel_tabs
.no_PSE:
           mov eax, PG_SW
           mov esi, tmp_page_tab
           mov ecx, 4096/4      ;0x0 - 0x00FFFFFF
.map_low:
           mov [esi], eax
           add eax, 0x1000
           mov [esi+4], eax
           add eax, 0x1000
           mov [esi+8], eax
           add eax, 0x1000
           mov [esi+12], eax
           add eax, 0x1000
           add esi, 16
           dec ecx
           jnz .map_low            ;ÿäðî
 
           mov ecx, [pg_data.kernel_tables]
           mov eax, tmp_page_tab+PG_SW
           mov edi, sys_pgdir
           mov esi, sys_master_tab
 
.map_kernel_tabs:
 
           mov [edi], eax
           mov [esi], eax
           add eax, 0x1000
           add edi, 4
           add esi, 4
           dec ecx
           jnz .map_kernel_tabs
 
           mov edi, tmp_page_tab
           bt [cpu_caps], CAPS_PSE
           jc @F
           add edi, 4096*4      ;skip low kernel memory
@@:
           mov ecx, [pg_data.kernel_tables]
           sub ecx, 4
           shl ecx, 10
           xor eax, eax
           cld
           rep stosd
 
           mov dword [sys_pgdir+0x600], sys_master_tab+PG_SW
           mov dword [sys_master_tab+0x600], sys_master_tab+PG_SW
           ret
endp
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
align 4
proc init_page_map
           mov edi, sys_pgmap
           mov ecx, 512/4
           xor eax,eax
           cld
           rep stosd
 
           not eax
           mov ecx, [pg_data.pagemap_size]
           sub ecx, 512
           shr ecx, 2
           rep stosd
 
           mov edi, sys_pgmap+512
           mov edx, [pg_data.pages_count]
           mov ecx, [pg_data.kernel_tables]
           bt [cpu_caps], CAPS_PSE
           jnc @f
           sub ecx, 4
@@:
           sub edx, 4096
           sub edx, ecx
           mov [pg_data.pages_free], edx
 
           xor eax, eax
           mov ebx, ecx
           shr ecx, 5
           rep stosd
 
           not eax
           mov ecx, ebx
           and ecx, 31
           shl eax, cl
           stosd
 
           mov [page_start], sys_pgmap+512
           mov ebx, sys_pgmap
           add ebx, [pg_data.pagemap_size]
           mov [page_end], ebx
 
           mov [pg_data.pg_mutex], 0
 
           ret
endp
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
           shl ebx, 3
           add eax,ebx
           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
           mov eax, [phis_addr]
           and eax, not 0xFFF
           or eax, [flags]
           mov ebx, [lin_addr]
           shr ebx, 12
           mov [pages_tab+ebx*4], eax
           mov eax, [lin_addr]
           invlpg [eax]
           ret
endp
 
align 4
proc free_page
;arg:  eax  page address
           pushfd
           cli
           inc [pg_data.pages_free]
           shr eax, 12              ;page index
           mov ebx, sys_pgmap
           bts [ebx], eax           ;that's all!
           shr eax, 3
           and eax, not 3           ;dword offset from page_map
           add eax, ebx
           cmp [page_start], eax
           ja @f
           popfd
           ret
@@:
           mov [page_start], eax
           popfd
           ret
endp
 
align 4
proc map_page_table stdcall,page_dir:dword, lin_addr:dword, phis_addr:dword
           mov ebx, [lin_addr]
           shr ebx, 22
           mov eax, [phis_addr]
           and eax, not 0xFFF
           or eax, PG_UW          ;+PG_NOCACHE
           mov ecx, [page_dir]
           mov dword [ecx+ebx*4], eax
           mov dword [master_tab+ebx*4], eax
           mov eax, [lin_addr]
           shr eax, 10
           add eax, pages_tab
           invlpg [eax]
           ret
endp
 
align 4
proc init_LFB
 
           cmp dword [LFBAddress], -1
           jne @f
 
           stdcall kernel_alloc, 0x280000
           mov [LFBAddress], eax
           ret
@@:
           test [SCR_MODE],word 0100000000000000b
           jz @f
           call map_LFB
@@:
           ret
endp
 
align 4
proc map_LFB
           locals
             pg_count dd ?
           endl
 
           mov edi, [LFBSize]
           mov esi, [LFBAddress]
           shr edi, 12
           mov [pg_count], edi
           shr edi, 10
 
           bt [cpu_caps], CAPS_PSE
           jnc .map_page_tables
           mov ebx, esi
           or esi, PG_LARGE+PG_UW
           shr ebx, 20
           mov ecx, ebx
@@:
           mov [sys_pgdir+ebx], esi
           add ebx, 4
           add esi, 0x00400000
           dec edi
           jnz @B
 
           or dword [sys_pgdir+ecx], PG_GLOBAL
           mov eax, cr3       ;flush TLB
           mov cr3, eax
           ret
 
.map_page_tables:
 
@@:
           call alloc_page
           stdcall map_page_table,sys_pgdir, esi, eax
           add esi, 0x00400000
           dec edi
           jnz @B
 
           mov eax, [LFBAddress]
           mov esi, eax
           shr esi, 10
           add esi, pages_tab
           or eax, PG_UW
           mov ecx, [pg_count]
           shr ecx, 2
.map:
           mov [esi], eax
           add eax, 0x1000
           mov [esi+4], eax
           add eax, 0x1000
           mov [esi+8], eax
           add eax, 0x1000
           mov [esi+12], eax
           add eax, 0x1000
           add esi, 16
           sub ecx, 1
           jnz .map
 
           mov eax, cr3       ;flush TLB
           mov cr3, eax
 
           ret
endp
 
align 4
proc new_mem_resize stdcall, new_size:dword
 
           stdcall wait_mutex, pg_data.pg_mutex
 
           mov edi, [new_size]
           add edi,4095
           and edi,not 4095
           mov [new_size], edi
 
           mov edx,[CURRENT_TASK]
           shl edx,8
           mov esi, [PROC_BASE+0x8c+edx]
           add esi, 4095
           and esi, not 4095
 
           cmp edi, esi
           jae .expand
 
           shr edi, 12
           shr esi, 12
@@:
           mov eax, [pages_tab+0x00181000+edi*4]
           test eax, 1
           jz .next
           mov dword [pages_tab+0x00181000+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]
           mov    [PROC_BASE+0x8c+edx],ebx
 
;search threads and update
;application memory size infomation
           mov    ecx,[PROC_BASE+0xb8+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+0xa],9 ;if slot empty?
           jz     .search_threads_next
           shl    edx,3
           cmp    [PROC_BASE+edx+0xb8],ecx     ;if it is our thread?
           jnz    .search_threads_next
           mov    [PROC_BASE+edx+0x8c],ebx     ;update memory size
.search_threads_next:
           inc    eax
           jmp    .search_threads
.search_threads_end:
           xor eax, eax
           dec [pg_data.pg_mutex]
           ret
 
.expand:
           add edi, new_app_base
           add esi, new_app_base
 
           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
 
           mov eax, cr3
           stdcall map_page,[tmp_task_pdir],eax,dword PG_SW+PG_NOCACHE
 
@@:
           call alloc_page
           test eax, eax
           jz .exit
 
           stdcall map_page_table,[tmp_task_pdir], edi, eax
 
           push edi
           shr edi, 10
           add edi, pages_tab
           mov ecx, 1024
           xor eax, eax
           cld
           rep stosd
           pop edi
 
           add edi, 0x00400000
           cmp edi, esi
           jb @B
 
           stdcall map_page,[tmp_task_pdir],dword 0,dword PG_UNMAP
.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
           jna @B
 
           jmp .update_size
.exit:
           xor eax, eax
           inc eax
           dec [pg_data.pg_mutex]
           ret
endp
 
align 4
proc get_pg_addr stdcall, lin_addr:dword
           mov ebx, [lin_addr]
           shr ebx, 12
           mov eax, [pages_tab+ebx*4]
           and eax, 0xFFFFF000
           ret
endp
 
align 16
proc page_fault_handler
           pushad
 
           mov ebp, esp
           mov eax, cr2
           sub esp, 4
           mov [esp], eax
           push ds
 
           mov ax, 0x10
           mov ds, ax
 
;     mov edx, 0x400   ;bocsh
;     mov al,0xff      ;bocsh
;     out dx, al       ;bocsh
;     nop              ;bocsh fix
 
 
           mov ebx, [ebp-4]
 
           cmp ebx, 0xe0000000
           jae .lfb_addr
 
           cmp ebx, 0x60400000
           jae .user_space
 
           cmp ebx, 0x60000000
           jae .tab_space
 
           jmp .kernel_space
 
.user_space:
           inc [pg_data.pages_faults]
 
           shr ebx, 12
           mov eax, [pages_tab+ebx*4]
 
           shr ebx, 10
           mov edx, [master_tab+ebx*4]
 
           test eax, 2
           jz .exit
 
           call alloc_page
           and eax, eax
           jz .exit
 
           stdcall map_page,[ebp-4],eax,dword PG_UW
 
           mov esi, [ebp-4]
           and esi, 0xFFFFF000
           mov ecx, 1024
           xor eax, eax
@@:
           mov [esi], eax
           add esi, 4
           dec ecx
           jnz @B
.exit:
           pop ds
           mov esp, ebp
           popad
           add esp, 4
           iretd
 
.kernel_space:
           shr ebx, 12
           mov eax, [pages_tab+ebx*4]
           shr ebx, 10
           mov eax, [master_tab+ebx*4]
 
           pop ds
           mov esp, ebp
           popad
           add esp, 4
           iretd
 
.old_addr:
           shr ebx, 12
;           mov eax, [pages_tab+ebx*4]
           shr ebx, 10
           mov eax, [master_tab+ebx*4]
 
           pop ds
           mov esp, ebp
           popad
           add esp, 4
           iretd
 
.lfb_addr:
           shr ebx, 22
           ;mov ecx, [sys_page_dir]
           mov eax, [master_tab+ebx*4]
 
           pop ds
           mov esp, ebp
           popad
           add esp, 4
           iretd
 
.tab_space:
           shr ebx, 12
;           mov eax, [pages_tab+ebx*4]
           shr ebx, 10
           ;mov ecx, [sys_page_dir]
           mov eax, [master_tab+ebx*4]
 
           pop ds
           mov esp, ebp
           popad
           add esp, 4
           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_TASK]
           shl  eax,8
           add  eax, PROC_BASE
           pushf
           cli
           mov  [eax+0xA0],ebx     ;set fields in extended information area
           mov  [eax+0xA4],ecx
 
           add ebx,  new_app_base
           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+PROC_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+PROC_BASE+0xa4]
           mov [buf_size], esi
 
           stdcall map_mem, [ipc_tmp], [PROC_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 [pages_tab+ebx*4], eax
           invlpg [edx]
 
           mov ebx, [ipc_pdir]
           mov edx, ebx
           shr ebx, 12
           xor eax, eax
           mov [pages_tab+ebx*4], eax
           invlpg [edx]
 
           mov ebx, [ipc_ptab]
           mov edx, ebx
           shr ebx, 12
           xor eax, eax
           mov [pages_tab+ebx*4], eax
           invlpg [edx]
 
           mov  eax, [dst_slot]
           shl eax, 8
           or   [eax+PROC_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
           mov eax, [pg_data.pages_count]
           mov [ebx], 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
 
align 4
new_services:
 
           cmp  eax,4
           jle  sys_sheduler
 
           cmp eax, 11
           jb .fail
           ja @f
 
;           add ebx, new_app_base
;           stdcall get_mem_info, ebx
;           mov [esp+36], eax
;           ret
;@@:
;           cmp eax, 11
;           ja @f
 
           stdcall init_heap, ebx
           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
           add ebx,new_app_base
           stdcall get_notify, ebx
           ret
@@:
           cmp eax, 15
           ja @f
           mov ecx, [CURRENT_TASK]
           shl ecx, 8
           mov eax, [ecx+PROC_BASE+APPDATA.fpu_handler]
           mov [ecx+PROC_BASE+APPDATA.fpu_handler], ebx
           mov [esp+36], eax
           ret
@@:
           cmp eax, 16
           ja @f
 
           add ebx, new_app_base
           stdcall get_service, ebx
           mov [esp+36], eax
           ret
@@:
           cmp eax, 17
           ja @f
           stdcall srv_handlerEx, ebx
           mov [esp+36], eax
           ret
@@:
           cmp eax, 18
           ja @f
           mov ecx, [CURRENT_TASK]
           shl ecx, 8
           mov eax, [ecx+PROC_BASE+APPDATA.sse_handler]
           mov [ecx+PROC_BASE+APPDATA.sse_handler], ebx
           mov [esp+36], eax
           ret
 
@@:
.fail:
           xor eax, eax
           mov [esp+36], eax
           ret
 
 
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 fpu_save
           clts
           mov ebx, [fpu_owner]
           shl ebx, 8
           mov eax, [ebx+PROC_BASE+0x10]
           mov ebx, [CURRENT_TASK]
           mov [fpu_owner], ebx
 
           bt [cpu_caps], CAPS_FXSR
           jnc .no_SSE
 
           fxsave [eax]
           ret
.no_SSE:
           fnsave [eax]
           ret
endp
 
align 4
proc fpu_restore
           mov ebx, [CURRENT_TASK]
           shl ebx, 8
           mov eax, [ebx+PROC_BASE+0x10]
           bt [cpu_caps], CAPS_FXSR
           jnc .no_SSE
 
           fxrstor [eax]
           ret
.no_SSE:
           frstor [eax]
           ret
endp
 
align 4
proc test_cpu
           locals
              cpu_type   dd ?
              cpu_id     dd ?
              cpu_Intel  dd ?
              cpu_AMD    dd ?
           endl
 
           mov [cpu_type], 0
 
           pushfd
           pop eax
           mov ecx, eax
           xor eax, 0x40000
           push eax
           popfd
           pushfd
           pop eax
           xor eax, ecx
           mov [cpu_type], CPU_386
           jz .end_cpu
           push ecx
           popfd
 
           mov [cpu_type], CPU_486
           mov eax, ecx
           xor eax, 0x200000
           push eax
           popfd
           pushfd
           pop eax
           xor eax, ecx
           je .end_cpu
           mov [cpu_id], 1
 
           xor eax, eax
           cpuid
           mov [cpu_vendor], ebx
           mov [cpu_vendor+4], edx
           mov [cpu_vendor+8], ecx
           cmp ebx, dword [intel_str]
           jne .check_AMD
           cmp edx, dword [intel_str+4]
           jne .check_AMD
           cmp ecx, dword [intel_str+8]
           jne .check_AMD
           mov [cpu_Intel], 1
           cmp eax, 1
           jl .end_cpuid
           mov eax, 1
           cpuid
           mov [cpu_sign], eax
           mov [cpu_info],  ebx
           mov [cpu_caps],  edx
           mov [cpu_caps+4],ecx
 
           shr eax, 8
           and eax, 0x0f
           mov [cpu_type], eax
           ret
 
.end_cpuid:
           mov eax, [cpu_type]
           ret
 
.check_AMD:
           cmp ebx, dword [AMD_str]
           jne .end_cpu
           cmp edx, dword [AMD_str+4]
           jne .end_cpu
           cmp ecx, dword [AMD_str+8]
           jne .end_cpu
           mov [cpu_AMD], 1
           cmp eax, 1
           jl .end_cpuid
           mov eax, 1
           cpuid
           mov [cpu_sign], eax
           mov [cpu_info],  ebx
           mov [cpu_caps],  edx
           mov [cpu_caps+4],ecx
           shr eax, 8
           and eax, 0x0f
           mov [cpu_type], eax
.end_cpu:
           mov eax, [cpu_type]
           ret
endp
 
MEM_WB     equ 6               ;write-back memory
MEM_WC     equ 1               ;write combined memory
MEM_UC     equ 0               ;uncached memory
 
align 4
proc init_mtrr
 
           cmp [0x2f0000+0x901c],byte 2
           je  .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
 
 
iglobal
align 4
  intel_str    db "GenuineIntel",0
  AMD_str      db "AuthenticAMD",0
endg
 
uglobal
align 16
  irq_tab           rd 16
 
 
  MEM_FreeSpace     rd 1
 
  ipc_tmp           rd 1
  ipc_pdir          rd 1
  ipc_ptab          rd 1
 
  proc_mem_map      rd 1
  proc_mem_pdir     rd 1
  proc_mem_tab      rd 1
 
  tmp_task_pdir     rd 1
  tmp_task_ptab     rd 1
  tmp_task_data     rd 1
 
  current_pdir      rd 1
 
  fpu_data          rd 1
  fdd_buff          rd 1
 
;;CPUID information
 
  cpu_vendor        rd 3
  cpu_sign          rd 1
  cpu_info          rd 1
 
endg
 
uglobal
align 16
   dll_tab         rb 32*32
   srv_tab         rb 32*32
   dll_map         rd 1
   srv_map         rd 1
 
   mem_used_list   rd 1
   mem_block_list  rd 64
   mem_block_map   rb 512
   mem_block_arr   rd 1
   mem_block_start rd 1
   mem_block_end   rd 1
   mem_block_mask  rd 2
   heap_size       rd 1
   heap_free       rd 1
   heap_blocks     rd 1
   free_blocks     rd 1
 
   page_start      rd 1
   page_end        rd 1
   sys_page_map    rd 1
;   app_load        rd 1
endg
 
 
;     push eax
;     push edx
;     mov edx, 0x400   ;bocsh
;     mov al,0xff      ;bocsh
;     out dx, al       ;bocsh
;     pop edx
 
;     pop eax

Rev 168	Rev 170
1	tmp_page_tab equ 0x01000000	1	tmp_page_tab equ 0x01000000
2		2
3	align 4	3	align 4
4	proc mem_test	4	proc mem_test
5	mov eax, cr0	5	mov eax, cr0
6	or eax, (CR0_CD+CR0_NW);disable caching	6	or eax, (CR0_CD+CR0_NW);disable caching
7	mov cr0, eax	7	mov cr0, eax
8	wbinvd ;invalidate cache	8	wbinvd ;invalidate cache
9		9
10	xor edi, edi	10	xor edi, edi
11	mov ebx, 'TEST'	11	mov ebx, 'TEST'
12	@@:	12	@@:
13	add edi, 0x400000	13	add edi, 0x400000
14	xchg ebx, dword [edi]	14	xchg ebx, dword [edi]
15	cmp dword [edi], 'TEST'	15	cmp dword [edi], 'TEST'
16	xchg ebx, dword [edi]	16	xchg ebx, dword [edi]
17	je @b	17	je @b
18		18
19	and eax, not (CR0_CD+CR0_NW)	19	and eax, not (CR0_CD+CR0_NW)
20	mov cr0, eax	20	mov cr0, eax
21	mov eax, edi	21	mov eax, edi
22	ret	22	ret
23	endp	23	endp
24		24
25	align 4	25	align 4
26	proc init_memEx	26	proc init_memEx
27	xor eax, eax	27	xor eax, eax
28	mov edi, sys_pgdir	28	mov edi, sys_pgdir
29	mov ecx, 2048	29	mov ecx, 2048
30	rep stosd	30	rep stosd
31		31
32	bt [cpu_caps], CAPS_PSE	32	bt [cpu_caps], CAPS_PSE
33	jnc .no_PSE	33	jnc .no_PSE
34		34
35	mov ebx, cr4	35	mov ebx, cr4
36	or ebx, CR4_PSE	36	or ebx, CR4_PSE
37	mov eax, PG_LARGE+PG_SW	37	mov eax, PG_LARGE+PG_SW
38	bt [cpu_caps], CAPS_PGE	38	bt [cpu_caps], CAPS_PGE
39	jnc @F	39	jnc @F
40	or eax, PG_GLOBAL	40	or eax, PG_GLOBAL
41	or ebx, CR4_PGE	41	or ebx, CR4_PGE
42		42
43	@@:	43	@@:
44	mov cr4, ebx	44	mov cr4, ebx
45		45
46	mov dword [sys_pgdir], eax	46	mov dword [sys_pgdir], eax
47	add eax, 0x00400000	47	add eax, 0x00400000
48	mov dword [sys_pgdir+4], eax	48	mov dword [sys_pgdir+4], eax
49	add eax, 0x00400000	49	add eax, 0x00400000
50	mov dword [sys_pgdir+8], eax	50	mov dword [sys_pgdir+8], eax
51	add eax, 0x00400000	51	add eax, 0x00400000
52	mov dword [sys_pgdir+12], eax	52	mov dword [sys_pgdir+12], eax
53		53
54	mov dword [sys_pgdir+0x600], sys_master_tab+PG_SW	54	mov dword [sys_pgdir+0x600], sys_master_tab+PG_SW
55	mov dword [sys_master_tab+0x600], sys_master_tab+PG_SW	55	mov dword [sys_master_tab+0x600], sys_master_tab+PG_SW
56		56
57	mov ecx, [pg_data.kernel_tables]	57	mov ecx, [pg_data.kernel_tables]
58	sub ecx, 4	58	sub ecx, 4
59	mov eax, tmp_page_tab+PG_SW	59	mov eax, tmp_page_tab+PG_SW
60	mov edi, sys_pgdir+16	60	mov edi, sys_pgdir+16
61	mov esi, sys_master_tab+16	61	mov esi, sys_master_tab+16
62		62
63	jmp .map_kernel_tabs	63	jmp .map_kernel_tabs
64	.no_PSE:	64	.no_PSE:
65	mov eax, PG_SW	65	mov eax, PG_SW
66	mov esi, tmp_page_tab	66	mov esi, tmp_page_tab
67	mov ecx, 4096/4 ;0x0 - 0x00FFFFFF	67	mov ecx, 4096/4 ;0x0 - 0x00FFFFFF
68	.map_low:	68	.map_low:
69	mov [esi], eax	69	mov [esi], eax
70	add eax, 0x1000	70	add eax, 0x1000
71	mov [esi+4], eax	71	mov [esi+4], eax
72	add eax, 0x1000	72	add eax, 0x1000
73	mov [esi+8], eax	73	mov [esi+8], eax
74	add eax, 0x1000	74	add eax, 0x1000
75	mov [esi+12], eax	75	mov [esi+12], eax
76	add eax, 0x1000	76	add eax, 0x1000
77	add esi, 16	77	add esi, 16
78	dec ecx	78	dec ecx
79	jnz .map_low ;ÿäðî	79	jnz .map_low ;ÿäðî
80		80
81	mov ecx, [pg_data.kernel_tables]	81	mov ecx, [pg_data.kernel_tables]
82	mov eax, tmp_page_tab+PG_SW	82	mov eax, tmp_page_tab+PG_SW
83	mov edi, sys_pgdir	83	mov edi, sys_pgdir
84	mov esi, sys_master_tab	84	mov esi, sys_master_tab
85		85
86	.map_kernel_tabs:	86	.map_kernel_tabs:
87		87
88	mov [edi], eax	88	mov [edi], eax
89	mov [esi], eax	89	mov [esi], eax
90	add eax, 0x1000	90	add eax, 0x1000
91	add edi, 4	91	add edi, 4
92	add esi, 4	92	add esi, 4
93	dec ecx	93	dec ecx
94	jnz .map_kernel_tabs	94	jnz .map_kernel_tabs
95		95
96	mov edi, tmp_page_tab	96	mov edi, tmp_page_tab
97	bt [cpu_caps], CAPS_PSE	97	bt [cpu_caps], CAPS_PSE
98	jc @F	98	jc @F
99	add edi, 4096*4 ;skip low kernel memory	99	add edi, 4096*4 ;skip low kernel memory
100	@@:	100	@@:
101	mov ecx, [pg_data.kernel_tables]	101	mov ecx, [pg_data.kernel_tables]
102	sub ecx, 4	102	sub ecx, 4
103	shl ecx, 10	103	shl ecx, 10
104	xor eax, eax	104	xor eax, eax
105	cld	105	cld
106	rep stosd	106	rep stosd
107		107
108	mov dword [sys_pgdir+0x600], sys_master_tab+PG_SW	108	mov dword [sys_pgdir+0x600], sys_master_tab+PG_SW
109	mov dword [sys_master_tab+0x600], sys_master_tab+PG_SW	109	mov dword [sys_master_tab+0x600], sys_master_tab+PG_SW
110	ret	110	ret
111	endp	111	endp
112		112
113	;align 4	-
114	;proc init_mem	-
115	;	-
116	; xor eax, eax	-
117	; mov edi, sys_pgdir	-
118	; mov ecx, 2048	-
119	; rep stosd	-
120	;	-
121	; bt [cpu_caps], CAPS_PSE	-
122	; jc .use_PSE	-
123	;	-
124	; mov eax, PG_SW	-
125	; mov esi, tmp_page_tab	-
126	; mov ecx, 4096/4 ;0x0 - 0x00FFFFFF	-
127	;	-
128	;.map_low:	-
129	; mov [esi], eax	-
130	; add eax, 0x1000	-
131	; mov [esi+4], eax	-
132	; add eax, 0x1000	-
133	; mov [esi+8], eax	-
134	; add eax, 0x1000	-
135	; mov [esi+12], eax	-
136	; add eax, 0x1000	-
137	; add esi, 16	-
138	; dec ecx	-
139	; jnz .map_low ;ÿäðî	-
140		-
141	; mov eax, tmp_page_tab+PG_SW	-
142	; mov ecx, 4	-
143	; xor ebx, ebx	-
144		-
145	;.map_page_tables:	-
146	; mov [sys_pgdir+ebx], eax	-
147	; mov [sys_master_tab+ebx], eax	-
148	; add eax, 0x1000	-
149	; add ebx, 4	-
150	; dec ecx	-
151	; jnz .map_page_tables	-
152		-
153	; mov dword [sys_pgdir+0x600], sys_master_tab+PG_SW	-
154	; mov dword [sys_master_tab+0x600], sys_master_tab+PG_SW	-
155		-
156	; ret	-
157		-
158	;.use_PSE:	-
159	; mov ebx, cr4	-
160	; or ebx, CR4_PSE	-
161	; mov eax, PG_LARGE+PG_SW	-
162	; bt [cpu_caps], CAPS_PGE	-
163	; jnc @F	-
164	; or eax, PG_GLOBAL	-
165	; or ebx, CR4_PGE	-
166	;@@:	-
167	; mov dword [sys_pgdir], eax	-
168	; add eax, 0x00400000	-
169	; mov dword [sys_pgdir+4], eax	-
170	; add eax, 0x00400000	-
171	; mov dword [sys_pgdir+8], eax	-
172	; add eax, 0x00400000	-
173	; mov dword [sys_pgdir+12], eax	-
174	;	-
175	; mov dword [sys_pgdir+0x600], sys_master_tab+PG_SW	-
176	; mov dword [sys_master_tab+0x600], sys_master_tab+PG_SW	-
177		-
178	; mov cr4, ebx	-
179	; ret	-
180	;endp	-
181		-
182	align 4	113	align 4
183	proc init_page_map	114	proc init_page_map
184	mov edi, sys_pgmap	115	mov edi, sys_pgmap
185	mov ecx, 512/4	116	mov ecx, 512/4
186	xor eax,eax	117	xor eax,eax
187	cld	118	cld
188	rep stosd	119	rep stosd
189		120
190	not eax	121	not eax
191	mov ecx, [pg_data.pagemap_size]	122	mov ecx, [pg_data.pagemap_size]
192	sub ecx, 512	123	sub ecx, 512
193	shr ecx, 2	124	shr ecx, 2
194	rep stosd	125	rep stosd
195		126
196	mov edi, sys_pgmap+512	127	mov edi, sys_pgmap+512
197	mov edx, [pg_data.pages_count]	128	mov edx, [pg_data.pages_count]
198	mov ecx, [pg_data.kernel_tables]	129	mov ecx, [pg_data.kernel_tables]
199	bt [cpu_caps], CAPS_PSE	130	bt [cpu_caps], CAPS_PSE
200	jnc @f	131	jnc @f
201	sub ecx, 4	132	sub ecx, 4
202	@@:	133	@@:
203	sub edx, 4096	134	sub edx, 4096
204	sub edx, ecx	135	sub edx, ecx
205	mov [pg_data.pages_free], edx	136	mov [pg_data.pages_free], edx
206		137
207	xor eax, eax	138	xor eax, eax
208	mov ebx, ecx	139	mov ebx, ecx
209	shr ecx, 5	140	shr ecx, 5
210	rep stosd	141	rep stosd
211		142
212	not eax	143	not eax
213	mov ecx, ebx	144	mov ecx, ebx
214	and ecx, 31	145	and ecx, 31
215	shl eax, cl	146	shl eax, cl
216	stosd	147	stosd
217		148
218	mov [page_start], sys_pgmap+512	149	mov [page_start], sys_pgmap+512
219	mov ebx, sys_pgmap	150	mov ebx, sys_pgmap
220	add ebx, [pg_data.pagemap_size]	151	add ebx, [pg_data.pagemap_size]
221	mov [page_end], ebx	152	mov [page_end], ebx
222		153
223	mov [pg_data.pg_mutex], 0	154	mov [pg_data.pg_mutex], 0
224		155
225	ret	156	ret
226	endp	157	endp
227		158
228	;align 4	-
229	;proc init_pg_mem	-
230	;	-
231	; mov edi, sys_pgmap	-
232	; mov ecx, 512/4	-
233	; xor eax,eax	-
234	; cld	-
235	; rep stosd	-
236	;	-
237	; not eax	-
238	; mov ecx, [pg_data.pagemap_size]	-
239	; sub ecx, 512	-
240	; shr ecx, 2	-
241	; rep stosd	-
242	;	-
243	; shl eax, PAGES_USED	-
244	; mov [sys_pgmap+512], eax	-
245	;	-
246	; mov [page_start], sys_pgmap+512	-
247	; mov ebx, sys_pgmap	-
248	; add ebx, [pg_data.pagemap_size]	-
249	; mov [page_end], ebx	-
250	; mov eax, [pg_data.pages_count]	-
251	; sub eax, 4096+PAGES_USED	-
252	; mov [pg_data.pages_free], eax	-
253	;	-
254	; mov [pg_data.pages_faults], 0	-
255	;	-
256	; mov edi, OS_BASE+0x01000000	-
257	; mov esi, [pg_data.kernel_tables]	-
258	; sub esi, 4	-
259	; ja @f	-
260	; mov esi, 1	-
261	;@@:	-
262	; call alloc_page	-
263	; stdcall map_page_table, sys_pgdir, edi, eax	-
264	; add edi, 0x00400000	-
265	; dec esi	-
266	; jnz @B	-
267	;	-
268	; mov ecx, [pg_data.kernel_tables]	-
269	; sub ecx, 4	-
270	; shl ecx, 10	-
271	; mov edi, OS_BASE+0x01000000	-
272	; shr edi, 10	-
273	; add edi, pages_tab	-
274	; xor eax, eax	-
275	; cld	-
276	; rep stosd	-
277	;	-
278	; mov eax, cr3	-
279	; mov cr3, eax	-
280	;	-
281	; mov [pg_data.pg_mutex], 0	-
282	; ret	-
283	;endp	-
284		-
285	align 4	159	align 4
286	proc alloc_page	160	proc alloc_page
287		161
288	pushfd	162	pushfd
289	cli	163	cli
290	mov ebx, [page_start]	164	mov ebx, [page_start]
291	mov ecx, [page_end]	165	mov ecx, [page_end]
292	.l1:	166	.l1:
293	bsf eax,[ebx];	167	bsf eax,[ebx];
294	jnz .found	168	jnz .found
295	add ebx,4	169	add ebx,4
296	cmp ebx, ecx	170	cmp ebx, ecx
297	jb .l1	171	jb .l1
298	popfd	172	popfd
299	xor eax,eax	173	xor eax,eax
300	ret	174	ret
301	.found:	175	.found:
302	btr [ebx], eax	176	btr [ebx], eax
303	mov [page_start],ebx	177	mov [page_start],ebx
304	sub ebx, sys_pgmap	178	sub ebx, sys_pgmap
305	shl ebx, 3	179	shl ebx, 3
306	add eax,ebx	180	add eax,ebx
307	shl eax, 12	181	shl eax, 12
308	dec [pg_data.pages_free]	182	dec [pg_data.pages_free]
309	popfd	183	popfd
310	ret	184	ret
311	endp	185	endp
312		186
313	align 4	187	align 4
314	proc alloc_pages stdcall, count:dword	188	proc alloc_pages stdcall, count:dword
315	pushfd	189	pushfd
316	cli	190	cli
317	mov eax, [count]	191	mov eax, [count]
318	add eax, 7	192	add eax, 7
319	shr eax, 3	193	shr eax, 3
320	mov [count], eax	194	mov [count], eax
321	cmp eax, [pg_data.pages_free]	195	cmp eax, [pg_data.pages_free]
322	ja .fail	196	ja .fail
323		197
324	mov ecx, [page_start]	198	mov ecx, [page_start]
325	mov ebx, [page_end]	199	mov ebx, [page_end]
326	.find:	200	.find:
327	mov edx, [count]	201	mov edx, [count]
328	mov edi, ecx	202	mov edi, ecx
329		203
330	.match:	204	.match:
331	cmp byte [ecx], 0xFF	205	cmp byte [ecx], 0xFF
332	jne .next	206	jne .next
333	dec edx	207	dec edx
334	jz .ok	208	jz .ok
335	inc ecx	209	inc ecx
336	cmp ecx,ebx	210	cmp ecx,ebx
337	jb .match	211	jb .match
338	.fail: xor eax, eax	212	.fail: xor eax, eax
339	popfd	213	popfd
340	ret	214	ret
341	.next:	215	.next:
342	inc ecx	216	inc ecx
343	cmp ecx, ebx	217	cmp ecx, ebx
344	jb .find	218	jb .find
345	popfd	219	popfd
346	xor eax, eax	220	xor eax, eax
347	ret	221	ret
348	.ok:	222	.ok:
349	sub ecx, edi	223	sub ecx, edi
350	inc ecx	224	inc ecx
351	mov esi, edi	225	mov esi, edi
352	xor eax, eax	226	xor eax, eax
353	rep stosb	227	rep stosb
354	sub esi, sys_pgmap	228	sub esi, sys_pgmap
355	shl esi, 3+12	229	shl esi, 3+12
356	mov eax, esi	230	mov eax, esi
357	mov ebx, [count]	231	mov ebx, [count]
358	shl ebx, 3	232	shl ebx, 3
359	sub [pg_data.pages_free], ebx	233	sub [pg_data.pages_free], ebx
360	popfd	234	popfd
361	ret	235	ret
362	endp	236	endp
363		237
364	align 4	238	align 4
365	proc map_page stdcall,lin_addr:dword,phis_addr:dword,flags:dword	239	proc map_page stdcall,lin_addr:dword,phis_addr:dword,flags:dword
366	mov eax, [phis_addr]	240	mov eax, [phis_addr]
367	and eax, not 0xFFF	241	and eax, not 0xFFF
368	or eax, [flags]	242	or eax, [flags]
369	mov ebx, [lin_addr]	243	mov ebx, [lin_addr]
370	shr ebx, 12	244	shr ebx, 12
371	mov [pages_tab+ebx*4], eax	245	mov [pages_tab+ebx*4], eax
372	mov eax, [lin_addr]	246	mov eax, [lin_addr]
373	invlpg [eax]	247	invlpg [eax]
374	ret	248	ret
375	endp	249	endp
376		250
377	align 4	251	align 4
378	proc free_page	252	proc free_page
379	;arg: eax page address	253	;arg: eax page address
380	pushfd	254	pushfd
381	cli	255	cli
382	inc [pg_data.pages_free]	256	inc [pg_data.pages_free]
383	shr eax, 12 ;page index	257	shr eax, 12 ;page index
384	mov ebx, sys_pgmap	258	mov ebx, sys_pgmap
385	bts [ebx], eax ;that's all!	259	bts [ebx], eax ;that's all!
386	shr eax, 3	260	shr eax, 3
387	and eax, not 3 ;dword offset from page_map	261	and eax, not 3 ;dword offset from page_map
388	add eax, ebx	262	add eax, ebx
389	cmp [page_start], eax	263	cmp [page_start], eax
390	ja @f	264	ja @f
391	popfd	265	popfd
392	ret	266	ret
393	@@:	267	@@:
394	mov [page_start], eax	268	mov [page_start], eax
395	popfd	269	popfd
396	ret	270	ret
397	endp	271	endp
398		272
399	align 4	273	align 4
400	proc map_page_table stdcall,page_dir:dword, lin_addr:dword, phis_addr:dword	274	proc map_page_table stdcall,page_dir:dword, lin_addr:dword, phis_addr:dword
401	mov ebx, [lin_addr]	275	mov ebx, [lin_addr]
402	shr ebx, 22	276	shr ebx, 22
403	mov eax, [phis_addr]	277	mov eax, [phis_addr]
404	and eax, not 0xFFF	278	and eax, not 0xFFF
405	or eax, PG_UW ;+PG_NOCACHE	279	or eax, PG_UW ;+PG_NOCACHE
406	mov ecx, [page_dir]	280	mov ecx, [page_dir]
407	mov dword [ecx+ebx*4], eax	281	mov dword [ecx+ebx*4], eax
408	mov dword [master_tab+ebx*4], eax	282	mov dword [master_tab+ebx*4], eax
409	mov eax, [lin_addr]	283	mov eax, [lin_addr]
410	shr eax, 10	284	shr eax, 10
411	add eax, pages_tab	285	add eax, pages_tab
412	invlpg [eax]	286	invlpg [eax]
413	ret	287	ret
414	endp	288	endp
415		289
416	align 4	290	align 4
417	proc init_LFB	291	proc init_LFB
418		292
419	cmp dword [LFBAddress], -1	293	cmp dword [LFBAddress], -1
420	jne @f	294	jne @f
421		295
422	stdcall kernel_alloc, 0x280000	296	stdcall kernel_alloc, 0x280000
423	mov [LFBAddress], eax	297	mov [LFBAddress], eax
424	ret	298	ret
425	@@:	299	@@:
426	test [SCR_MODE],word 0100000000000000b	300	test [SCR_MODE],word 0100000000000000b
427	jz @f	301	jz @f
428	call map_LFB	302	call map_LFB
429	@@:	303	@@:
430	ret	304	ret
431	endp	305	endp
432		306
433	align 4	307	align 4
434	proc map_LFB	308	proc map_LFB
435	locals	309	locals
436	pg_count dd ?	310	pg_count dd ?
437	endl	311	endl
438		312
439	mov edi, [LFBSize]	313	mov edi, [LFBSize]
440	mov esi, [LFBAddress]	314	mov esi, [LFBAddress]
441	shr edi, 12	315	shr edi, 12
442	mov [pg_count], edi	316	mov [pg_count], edi
443	shr edi, 10	317	shr edi, 10
444		318
445	bt [cpu_caps], CAPS_PSE	319	bt [cpu_caps], CAPS_PSE
446	jnc .map_page_tables	320	jnc .map_page_tables
447	mov ebx, esi	321	mov ebx, esi
448	or esi, PG_LARGE+PG_UW	322	or esi, PG_LARGE+PG_UW
449	shr ebx, 20	323	shr ebx, 20
450	mov ecx, ebx	324	mov ecx, ebx
451	@@:	325	@@:
452	mov [sys_pgdir+ebx], esi	326	mov [sys_pgdir+ebx], esi
453	add ebx, 4	327	add ebx, 4
454	add esi, 0x00400000	328	add esi, 0x00400000
455	dec edi	329	dec edi
456	jnz @B	330	jnz @B
457		331
458	or dword [sys_pgdir+ecx], PG_GLOBAL	332	or dword [sys_pgdir+ecx], PG_GLOBAL
459	mov eax, cr3 ;flush TLB	333	mov eax, cr3 ;flush TLB
460	mov cr3, eax	334	mov cr3, eax
461	ret	335	ret
462		336
463	.map_page_tables:	337	.map_page_tables:
464		338
465	@@:	339	@@:
466	call alloc_page	340	call alloc_page
467	stdcall map_page_table,sys_pgdir, esi, eax	341	stdcall map_page_table,sys_pgdir, esi, eax
468	add esi, 0x00400000	342	add esi, 0x00400000
469	dec edi	343	dec edi
470	jnz @B	344	jnz @B
471		345
472	mov eax, [LFBAddress]	346	mov eax, [LFBAddress]
473	mov esi, eax	347	mov esi, eax
474	shr esi, 10	348	shr esi, 10
475	add esi, pages_tab	349	add esi, pages_tab
476	or eax, PG_UW	350	or eax, PG_UW
477	mov ecx, [pg_count]	351	mov ecx, [pg_count]
478	shr ecx, 2	352	shr ecx, 2
479	.map:	353	.map:
480	mov [esi], eax	354	mov [esi], eax
481	add eax, 0x1000	355	add eax, 0x1000
482	mov [esi+4], eax	356	mov [esi+4], eax
483	add eax, 0x1000	357	add eax, 0x1000
484	mov [esi+8], eax	358	mov [esi+8], eax
485	add eax, 0x1000	359	add eax, 0x1000
486	mov [esi+12], eax	360	mov [esi+12], eax
487	add eax, 0x1000	361	add eax, 0x1000
488	add esi, 16	362	add esi, 16
489	sub ecx, 1	363	sub ecx, 1
490	jnz .map	364	jnz .map
491		365
492	mov eax, cr3 ;flush TLB	366	mov eax, cr3 ;flush TLB
493	mov cr3, eax	367	mov cr3, eax
494		368
495	ret	369	ret
496	endp	370	endp
497		371
498	align 4	372	align 4
499	proc new_mem_resize stdcall, new_size:dword	373	proc new_mem_resize stdcall, new_size:dword
500		374

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/memory.inc – Rev 168 → 170