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


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/memory.inc – Rev 363 → 365