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


tmp_page_tab      equ 0x00C00000
 
align 4
proc mem_test
 
           mov eax, cr0
           and eax, not (CR0_CD+CR0_NW)
           or eax, CR0_CD         ;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)  ;enable caching
           mov cr0, eax
           mov eax, edi
           mov [LFBSize], 0x00800000
           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
 
           mov dword [sys_pgdir+0x600], sys_pgdir+PG_SW
 
           mov ecx, [pg_data.kernel_tables]
           sub ecx, 3 ;4
           mov eax, tmp_page_tab+PG_SW
           mov edi, sys_pgdir+12     ;16
 
           jmp .map_kernel_tabs
.no_PSE:
           mov eax, PG_SW
           mov esi, tmp_page_tab
           mov ecx, 3072/4;  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
 
.map_kernel_tabs:
 
           mov [edi], eax
           add eax, 0x1000
           add edi, 4
           dec ecx
           jnz .map_kernel_tabs
 
           mov edi, tmp_page_tab
           bt [cpu_caps], CAPS_PSE
           jc @F
           add edi, 3072*4    ;4096*4  ;skip low kernel memory
@@:
           mov ecx, [pg_data.kernel_tables]
           sub ecx, 3
           shl ecx, 10
           xor eax, eax
           cld
           rep stosd
 
           mov dword [sys_pgdir+0x600], sys_pgdir+PG_SW
 
           ret
endp
 
align 4
proc init_page_map
           mov edi, sys_pgmap
           mov ecx, 384/4
           xor eax,eax
           cld
           rep stosd
 
           not eax
           mov ecx, [pg_data.pagemap_size]
           sub ecx, 384
           shr ecx, 2
           rep stosd
 
           mov edi, sys_pgmap+384
           mov edx, [pg_data.pages_count]
           mov ecx, [pg_data.kernel_tables]
           bt [cpu_caps], CAPS_PSE
           jnc @f
           sub ecx, 3
@@:
           sub edx, 3072
           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+384
           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
           lea eax, [eax+ebx*8]
           shl eax, 12
           dec [pg_data.pages_free]
           popfd
           ret
endp
 
align 4
proc alloc_pages stdcall, count:dword
           pushfd
           cli
           mov eax, [count]
           add eax, 7
           shr eax, 3
           mov [count], eax
           cmp eax, [pg_data.pages_free]
           ja .fail
 
           mov ecx, [page_start]
           mov ebx, [page_end]
.find:
           mov edx, [count]
           mov edi, ecx
.match:
           cmp byte [ecx], 0xFF
           jne .next
           dec edx
           jz .ok
           inc ecx
           cmp ecx,ebx
           jb .match
.fail:     xor eax, eax
           popfd
           ret
.next:
           inc ecx
           cmp ecx, ebx
           jb .find
           popfd
           xor eax, eax
           ret
.ok:
           sub ecx, edi
           inc ecx
           mov esi, edi
           xor eax, eax
           rep stosb
           sub esi, sys_pgmap
           shl esi, 3+12
           mov eax, esi
           mov ebx, [count]
           shl ebx, 3
           sub [pg_data.pages_free], ebx
           popfd
           ret
endp
 
align 4
proc map_page stdcall,lin_addr:dword,phis_addr:dword,flags:dword
           push ebx
           mov eax, [phis_addr]
           and eax, not 0xFFF
           or eax, [flags]
           mov ebx, [lin_addr]
           shr ebx, 12
           mov [pages_tab+ebx*4], eax
           mov eax, [lin_addr]
           invlpg [eax]
           pop ebx
           ret
endp
 
align 4
map_space:    ;not implemented
 
 
           ret
 
 
align 4
proc free_page
;arg:  eax  page address
           pushfd
           cli
           shr eax, 12              ;page index
           mov ebx, sys_pgmap
           bts [ebx], eax           ;that's all!
           cmc
           adc [pg_data.pages_free], 0
           shr eax, 3
           and eax, not 3           ;dword offset from page_map
           add eax, ebx
           cmp [page_start], eax
           ja @f
           popfd
           ret
@@:
           mov [page_start], eax
           popfd
           ret
endp
 
; param
;  eax= page base + page flags
;  ebx= liear address
;  ecx= count
 
align 4
commit_pages:
 
           test ecx, ecx
           jz .fail
 
           mov edi, ebx
           mov ebx, pg_data.pg_mutex
           call wait_mutex      ;ebx
 
           mov edx, 0x1000
           mov ebx, edi
           shr ebx, 12
@@:
           mov [pages_tab+ebx*4], eax
           invlpg [edi]
           add edi, edx
           add eax, edx
           inc ebx
           dec ecx
           jnz @B
           mov [pg_data.pg_mutex],ecx
.fail:
           ret
 
 
; param
;  eax= base
;  ecx= count
 
align 4
release_pages:
 
           pushad
           mov ebx, pg_data.pg_mutex
           call wait_mutex      ;ebx
 
           mov esi, eax
           mov edi, eax
 
           shr esi, 10
           add esi, pages_tab
 
           mov ebp, [pg_data.pages_free]
           mov ebx, [page_start]
           mov edx, sys_pgmap
@@:
           xor eax, eax
           xchg eax, [esi]
           invlpg [edi]
 
           test eax, 1
           jz .next
 
           shr eax, 12
           bts [edx], eax
           cmc
           adc ebp, 0
           shr eax, 3
           and eax, -4
           add eax, edx
           cmp eax, ebx
           jae .next
 
           mov ebx, eax
.next:
           add edi, 0x1000
           add esi, 4
           dec ecx
           jnz @B
           mov [pg_data.pages_free], ebp
           and [pg_data.pg_mutex],0
           popad
           ret
 
align 4
proc map_page_table stdcall, lin_addr:dword, phis_addr:dword
           push ebx
           mov ebx, [lin_addr]
           shr ebx, 22
           mov eax, [phis_addr]
           and eax, not 0xFFF
           or eax, PG_UW          ;+PG_NOCACHE
           mov dword [current_pgdir+ebx*4], eax
           mov eax, [lin_addr]
           shr eax, 10
           add eax, pages_tab
           invlpg [eax]
           pop ebx
           ret
endp
 
align 4
proc init_LFB
           cmp dword [LFBAddress], -1
           jne @f
           mov [0x2f0000+0x901c],byte 2
           stdcall kernel_alloc, 0x280000
           mov [LFBAddress], eax
           ret
@@:
           test [SCR_MODE],word 0100000000000000b
           jnz @f
           mov [0x2f0000+0x901c],byte 2
           ret
@@:
           call map_LFB
           ret
endp
 
align 4
proc map_LFB
           locals
             pg_count dd ?
           endl
 
           mov edi, [LFBSize]
           mov esi, [LFBAddress]
           mov dword [exp_lfb+4], esi
 
           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
 
           bt [cpu_caps], CAPS_PGE
           jnc @F
           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, 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
 
           mov ebx, pg_data.pg_mutex
           call wait_mutex    ;ebx
 
           mov edi, [new_size]
           add edi,4095
           and edi,not 4095
           mov [new_size], edi
 
           mov edx,[CURRENT_TASK]
           shl edx,8
           cmp [PROC_BASE+APPDATA.heap_base+edx],0
           jne .exit
 
           mov esi, [PROC_BASE+APPDATA.mem_size+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]
        call    update_mem_size
 
           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
 
@@:
           call alloc_page
           test eax, eax
           jz .exit
 
           stdcall map_page_table, 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
.grow:
           pop edi
           pop esi
@@:
           call alloc_page
           test eax, eax
           jz .exit
           stdcall map_page,esi,eax,dword PG_UW
 
           push edi
           mov edi, esi
           xor eax, eax
           mov ecx, 1024
           cld
           rep stosd
           pop edi
 
           add esi, 0x1000
           cmp esi, edi
           jb  @B
 
           jmp .update_size
.exit:
           xor eax, eax
           inc eax
           dec [pg_data.pg_mutex]
           ret
endp
 
update_mem_size:
; in: edx = slot shl 8
;     ebx = new memory size
; destroys eax,ecx,edx
 
           mov    [PROC_BASE+APPDATA.mem_size+edx],ebx
;search threads and update
;application memory size infomation
           mov    ecx,[PROC_BASE+APPDATA.dir_table+edx]
           mov    eax,2
 
.search_threads:
;eax = current slot
;ebx = new memory size
;ecx = page directory
           cmp    eax,[TASK_COUNT]
           jg     .search_threads_end
           mov    edx,eax
           shl    edx,5
           cmp    word [CURRENT_TASK+edx+TASKDATA.state],9 ;if slot empty?
           jz     .search_threads_next
           shl    edx,3
           cmp    [PROC_BASE+edx+APPDATA.dir_table],ecx     ;if it is our thread?
           jnz    .search_threads_next
           mov    [PROC_BASE+edx+APPDATA.mem_size],ebx     ;update memory size
.search_threads_next:
           inc    eax
           jmp    .search_threads
.search_threads_end:
           ret
 
; param
;  eax= linear address
;
; retval
;  eax= phisical page address
 
align 4
get_pg_addr:
           shr eax, 12
           mov eax, [pages_tab+eax*4]
           and eax, 0xFFFFF000
           ret
 
align 4
proc page_fault_handler
           pushad
 
           mov ebp, esp
           mov eax, cr2
           push eax
           push ds
           push es
 
           mov ax, 0x10
           mov ds, ax
           mov es, ax
 
           inc [pg_data.pages_faults]
 
           mov ebx, [ebp-4]
 
           cmp ebx, 0xe0000000
           jae .lfb_addr
 
           cmp ebx, 0x60400000
           jae .user_space
 
           cmp ebx, master_tab+0x1000
           jae .alloc
 
           cmp ebx, 0x60000000
           jae .tab_space
 
           jmp .kernel_space
 
.user_space:
           shr ebx, 12
           mov ecx, ebx
           shr ecx, 10
           mov edx, [master_tab+ecx*4]
           test edx, 1
           jz .fail
 
           mov eax, [pages_tab+ebx*4]
           test eax, 2
           jz .fail
.alloc:
           call alloc_page
           and eax, eax
           jz .exit
 
           stdcall map_page,[ebp-4],eax,dword PG_UW
 
           mov edi, [ebp-4]
           and edi, 0xFFFFF000
           mov ecx, 1024
           xor eax, eax
           cld
           rep stosd
.exit:
           pop es
           pop ds
           mov esp, ebp
           popad
           add esp, 4
           iretd
.fail:
           pop es
           pop ds
           mov esp, ebp
           popad
           add esp, 4
 
           save_ring3_context     ;debugger support
 
           mov bl, 14
           jmp exc_c
           iretd
 
.kernel_space:
;           shr ebx, 12
;           mov eax, [pages_tab+ebx*4]
;           shr ebx, 10
;           mov eax, [master_tab+ebx*4]
           jmp .exit
.old_addr:
;           shr ebx, 12
;           mov eax, [pages_tab+ebx*4]
;           shr ebx, 10
;           mov eax, [master_tab+ebx*4]
           jmp .exit
.lfb_addr:
;           shr ebx, 22
;           ;mov ecx, [sys_page_dir]
;           mov eax, [master_tab+ebx*4]
           jmp .exit
.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]
           jmp .exit
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
           cmp ebx, new_app_base
           jb .fail
 
           mov eax, [pg_data.pages_count]
           mov [ebx], eax
           shl eax, 12
           mov [esp+36], eax
           mov ecx, [pg_data.pages_free]
           mov [ebx+4], ecx
           mov edx, [pg_data.pages_faults]
           mov [ebx+8], edx
           mov esi, [heap_size]
           mov [ebx+12], esi
           mov edi, [heap_free]
           mov [ebx+16], edi
           mov eax, [heap_blocks]
           mov [ebx+20], eax
           mov ecx, [free_blocks]
           mov [ebx+24], ecx
           ret
.fail:
           mov dword [esp+36], -1
           ret
 
align 4
new_services:
 
           cmp  eax,4
           jle  sys_sheduler
 
           cmp eax, 11
           jb .fail
           ja @f
 
           call init_heap
           mov [esp+36], eax
           ret
@@:
           cmp eax, 12
           ja @f
 
           stdcall user_alloc, ebx
           mov [esp+36], eax
           ret
@@:
           cmp eax, 13
           ja @f
           add ebx, new_app_base
           stdcall user_free, ebx
           mov [esp+36], eax
           ret
@@:
           cmp eax, 14
           ja @f
           add ebx, new_app_base
           cmp ebx, new_app_base
           jb .fail
           stdcall get_event_ex, ebx, ecx
           mov [esp+36], eax
           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
 
           test ebx, ebx
           jz .fail
           add ebx, new_app_base
           cmp ebx, new_app_base
           jb .fail
           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
@@:
           cmp eax, 19
           ja .fail
           add ebx, new_app_base
           cmp ebx, new_app_base
           jb .fail
           stdcall load_library, 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 test_cpu
           locals
              cpu_type   dd ?
              cpu_id     dd ?
              cpu_Intel  dd ?
              cpu_AMD    dd ?
           endl
 
           mov [cpu_type], 0
           xor eax, eax
           mov [cpu_caps], eax
           mov [cpu_caps+4], eax
 
           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_cpuid
           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_cpuid
           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
           ret
.end_cpuid:
           mov eax, [cpu_type]
           ret
 
.check_AMD:
           cmp ebx, dword [AMD_str]
           jne .unknown
           cmp edx, dword [AMD_str+4]
           jne .unknown
           cmp ecx, dword [AMD_str+8]
           jne .unknown
           mov [cpu_AMD], 1
           cmp eax, 1
           jl .unknown
           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
           ret
.unknown:
           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
           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
 
           bt [cpu_caps], CAPS_MTRR
           jnc .exit
 
           mov eax, cr0
           or eax, 0x60000000   ;disable caching
           mov cr0, eax
           wbinvd               ;invalidate cache
 
           mov ecx, 0x2FF
           rdmsr                ;
           push eax
 
           xor edx, edx
           xor eax, eax
           mov ecx, 0x2FF
           wrmsr                ;disable all MTRR
 
           stdcall set_mtrr, dword 0,dword 0,[MEM_AMOUNT],MEM_WB
           stdcall set_mtrr, dword 1,[LFBAddress],[LFBSize],MEM_WC
           xor edx, edx
           xor eax, eax
           mov ecx, 0x204
           mov ebx, 6
@@:
           wrmsr                ;disable unused MTRR
           inc ecx
           wrmsr
           inc ecx
           dec ebx
           jnz @b
 
           wbinvd               ;again invalidate
 
           pop eax
           or eax, 0x800        ;set default memtype to UC
           and al, 0xF0
           mov ecx, 0x2FF
           wrmsr                ;and enable MTRR
 
           mov eax, cr0
           and eax, not 0x60000000
           mov cr0, eax         ; enable caching
.exit:
           ret
endp
 
align 4
proc set_mtrr stdcall, reg:dword,base:dword,size:dword,mem_type:dword
 
           xor edx, edx
           mov eax, [base]
           or eax, [mem_type]
           mov ecx, [reg]
           lea ecx, [0x200+ecx*2]
           wrmsr
 
           mov ebx, [size]
           dec ebx
           mov eax, 0xFFFFFFFF
           mov edx, 0x0000000F
           sub eax, ebx
           sbb edx, 0
           or eax, 0x800
           inc ecx
           wrmsr
           ret
endp
 
align 4
proc stall stdcall, delay:dword
           push ecx
           push edx
           push ebx
           push eax
 
           mov eax, [delay]
           mul [stall_mcs]
           mov ebx, eax       ;low
           mov ecx, edx       ;high
           rdtsc
           add ebx, eax
           adc ecx,edx
@@:
           rdtsc
           sub eax, ebx
           sbb edx, ecx
           jb @B
 
           pop eax
           pop ebx
           pop edx
           pop ecx
           ret
endp
 
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
 
  fpu_data          rd 1
  fdd_buff          rd 1
  LFBSize           rd 1
 
  stall_mcs         rd 1
;;CPUID information
 
  cpu_vendor        rd 3
  cpu_sign          rd 1
  cpu_info          rd 1
 
;;;;;   cursors data
 
align 16
cur_saved_data   rb 4096
 
 
 
 
 
 
def_cursor       rd 1
hw_cursor        rd 1
 
scr_width        rd 1
scr_height       rd 1
 
cur_def_interl   rd 1
cur_saved_base   rd 1
cur_saved_interl rd 1
cur_saved_w      rd 1
cur_saved_h      rd 1
 
endg
 
uglobal
align 16
 
   mst MEM_STATE
 
 
 
   mem_block_map   rb 512
   event_map       rb 64
   mem_block_list  rd 64
   mem_block_mask  rd 2
 
 
 
 
   srv.fd          rd 1
   srv.bk          rd 1
 
   mem_used_list   rd 1
   mem_block_arr   rd 1
   mem_block_start rd 1
   mem_block_end   rd 1
 
   heap_mutex      rd 1
   heap_size       rd 1
   heap_free       rd 1
   heap_blocks     rd 1
   free_blocks     rd 1
 
   page_start      rd 1
   page_end        rd 1
   events          rd 1
   event_start     rd 1
   event_end       rd 1
   event_uid       rd 1
 
   sys_page_map    rd 1
endg
 
if 0
     push eax
     push edx
     mov edx, 0x400   ;bocsh
     mov al,0xff      ;bocsh
     out dx, al       ;bocsh
     pop edx
     pop eax
end if
 
align 4
k_strrchr:
        push eax
        xor eax,eax
        or  ecx,-1
        repne scasb
        add ecx,1
        neg ecx
        sub edi,1
        pop eax
        std
        repne scasb
        cld
        add edi,1
 
        cmp [edi],al
        jne @F
        mov eax,edi
        ret
@@:
        xor eax,eax
        ret
 
align 4
proc k_strncpy stdcall, dest:dword, src:dword, maxlen:dword
        mov eax, [dest]
        mov esi, [src]
        mov ecx, [maxlen]
        test eax, eax
        jz .L9
        test esi, esi
        jz .L9
        test ecx, ecx
        jz .L9
 
        sub  esi, eax
        jmp .L1
 
align 4
.L2:
        mov edx, [esi+eax]
        mov [eax], dl
        test dl, dl
        jz .L7
 
        mov [eax+1], dh
        test dh, dh
        jz .L6
 
        shr edx, 16
        mov [eax+2],dl
        test dl, dl
        jz .L5
 
        mov [eax+3], dh
        test dh, dh
        jz .L4
        add eax, 4
.L1:
        sub ecx, 4
        jae .L2
 
        add ecx, 4
        jz .L9
 
        mov dl, [eax+esi]
        mov [eax], dl
        test dl, dl
        jz .L3
 
        inc eax
        dec ecx
        jz .L9
 
        mov dl, [eax+esi]
        mov [eax], dl
        test dl, dl
        jz .L3
 
        inc eax
        dec ecx
        jz .L9
 
        mov dl, [eax+esi]
        mov [eax], dl
        test dl, dl
        jz .L3
 
        inc eax
        jmp .L9
 
.L4:    dec ecx
        inc eax
 
.L5:    dec ecx
        inc eax
 
.L6:    dec ecx
        inc eax
.L7:
        add ecx,3
        jz .L9
.L8:
        mov byte [ecx+eax], 0
.L3:
        dec ecx
        jnz .L8
.L9:
	ret
endp
 
if 0
 
magic equ 0xfefefeff
 
k_strlen:
        mov eax,[esp+4]
        mov edx, 3
 
        and edx, eax
        jz .L1
        jp .L0
 
        cmp dh, byte [eax]
        je .L2
 
        inc eax
        cmp dh, byte [eax]
 
        je .L2
 
        inc eax
        xor edx, 2
 
        jz .L1
.L0:
        cmp dh, [eax]
        je .L2
 
        inc eax
        xor edx, edx
 
.L1:
        mov ecx, [eax]
        add eax, 4
 
        sub edx, ecx
        add ecx, magic
 
        dec edx
        jnc .L3
 
        xor edx, ecx
        and edx, not magic
        jne .L3
 
        mov ecx, [eax]
        add eax, 4
 
        sub edx, ecx
        add ecx, magic
        dec edx
        jnc .L3
 
        xor edx, ecx
        and edx, not magic
        jne .L3
 
        mov ecx, [eax]
        add eax, 4
 
        sub edx, ecx
        add ecx, magic
 
        dec edx
        jnc .L3
 
        xor edx, ecx
 
        and edx, not magic
        jne .L3
 
        mov ecx, [eax]
        add eax, 4
 
        sub edx, ecx
        add ecx, magic
 
        dec edx
        jnc .L3
 
        xor edx, ecx
 
        and edx, not magic
        je .L1
 
.L3:    sub eax ,4
        sub ecx, magic
 
        cmp cl, 0
        jz .L2
 
        inc eax
        test ch, ch
        jz .L2
 
        shr ecx, 16
        inc eax
 
        cmp cl,0
        jz .L2
 
        inc eax
 
.L2:
        sub eax, [esp+4]
	ret
 
end if

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/memory.inc @ 328 – Rev 328 → 354