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_mem
;
;           xor eax, eax
;           mov edi, sys_pgdir
;           mov ecx, 2048
;           rep stosd
;
;           bt [cpu_caps], CAPS_PSE
;           jc .use_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 eax, tmp_page_tab+PG_SW
;           mov ecx, 4
;           xor ebx, ebx
 
;.map_page_tables:
;           mov [sys_pgdir+ebx], eax
;           mov [sys_master_tab+ebx], eax
;           add eax, 0x1000
;           add ebx, 4
;           dec ecx
;           jnz .map_page_tables
 
;           mov dword [sys_pgdir+0x600], sys_master_tab+PG_SW
;           mov dword [sys_master_tab+0x600], sys_master_tab+PG_SW
 
;           ret
 
;.use_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 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 cr4, ebx
;           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 init_pg_mem
;
;           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
;
;           shl eax, PAGES_USED
;           mov [sys_pgmap+512], eax
;
;           mov [page_start], sys_pgmap+512
;           mov ebx, sys_pgmap
;           add ebx, [pg_data.pagemap_size]
;           mov [page_end], ebx
;           mov eax, [pg_data.pages_count]
;           sub eax, 4096+PAGES_USED
;           mov [pg_data.pages_free], eax
;
;           mov [pg_data.pages_faults], 0
;
;           mov edi, OS_BASE+0x01000000
;           mov esi, [pg_data.kernel_tables]
;           sub esi, 4
;           ja @f
;           mov esi, 1
;@@:
;           call alloc_page
;           stdcall map_page_table, sys_pgdir, edi, eax
;           add edi, 0x00400000
;           dec esi
;           jnz @B
;
;           mov ecx, [pg_data.kernel_tables]
;           sub ecx, 4
;           shl ecx, 10
;           mov edi, OS_BASE+0x01000000
;           shr edi, 10
;           add edi, pages_tab
;           xor eax, eax
;           cld
;           rep stosd
;
;           mov eax, cr3
;           mov cr3, eax
;
;           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
proc get_mem_info stdcall, val:dword
 
           mov esi, [val]
 
           mov eax, [pg_data.pages_count]
           mov [esi], eax
           mov ebx, [pg_data.pages_free]
           mov [esi+4], ebx
           mov ecx, [pg_data.pages_faults]
           mov [esi+8], ecx
 
           ret
endp
 
align 4
new_services:
 
           cmp  eax,4
           jle  sys_sheduler
 
           cmp eax, 10
           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
 
   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
;     nop              ;bocsh fix
;     pop edx
;     pop eax

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

Subversion Repositories Kolibri OS

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