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


tmp_page_tab      equ 0x01000000
 
align 4
proc mem_test
           mov eax, cr0
           or eax, (CR0_CD+CR0_NW);disable caching
           mov cr0, eax
           wbinvd                 ;invalidate cache
 
           xor     edi, edi
           mov ebx, 'TEST'
@@:
           add edi, 0x400000
           xchg ebx, dword [edi]
           cmp dword [edi], 'TEST'
           xchg ebx, dword [edi]
           je @b
 
           and eax, not (CR0_CD+CR0_NW)
           mov cr0, eax
           mov eax, edi
           ret
endp
 
align 4
proc init_memEx
           xor eax, eax
           mov edi, sys_pgdir
           mov ecx, 2048
           rep stosd
 
           bt [cpu_caps], CAPS_PSE
           jnc .no_PSE
 
           mov ebx, cr4
           or ebx, CR4_PSE
           mov eax, PG_LARGE+PG_SW
           bt [cpu_caps], CAPS_PGE
           jnc @F
           or eax, PG_GLOBAL
           or ebx, CR4_PGE
@@:
 
           mov cr4, ebx
 
           mov dword [sys_pgdir], eax
           add eax, 0x00400000
           mov dword [sys_pgdir+4], eax
           add eax, 0x00400000
           mov dword [sys_pgdir+8], eax
           add eax, 0x00400000
           mov dword [sys_pgdir+12], eax
 
           mov dword [sys_pgdir+0x600], sys_pgdir+PG_SW
 
           mov ecx, [pg_data.kernel_tables]
           sub ecx, 4
           mov eax, tmp_page_tab+PG_SW
           mov edi, sys_pgdir+16
 
           jmp .map_kernel_tabs
.no_PSE:
           mov eax, PG_SW
           mov esi, tmp_page_tab
           mov ecx, 4096/4      ;0x0 - 0x00FFFFFF
.map_low:
           mov [esi], eax
           add eax, 0x1000
           mov [esi+4], eax
           add eax, 0x1000
           mov [esi+8], eax
           add eax, 0x1000
           mov [esi+12], eax
           add eax, 0x1000
           add esi, 16
           dec ecx
           jnz .map_low            ;ÿäðî
 
           mov ecx, [pg_data.kernel_tables]
           mov eax, tmp_page_tab+PG_SW
           mov edi, sys_pgdir
 
.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, 4096*4      ;skip low kernel memory
@@:
           mov ecx, [pg_data.kernel_tables]
           sub ecx, 4
           shl ecx, 10
           xor eax, eax
           cld
           rep stosd
 
           mov dword [sys_pgdir+0x600], sys_pgdir+PG_SW
 
           ret
endp
 
align 4
proc init_page_map
           mov edi, sys_pgmap
           mov ecx, 512/4
           xor eax,eax
           cld
           rep stosd
 
           not eax
           mov ecx, [pg_data.pagemap_size]
           sub ecx, 512
           shr ecx, 2
           rep stosd
 
           mov edi, sys_pgmap+512
           mov edx, [pg_data.pages_count]
           mov ecx, [pg_data.kernel_tables]
           bt [cpu_caps], CAPS_PSE
           jnc @f
           sub ecx, 4
@@:
           sub edx, 4096
           sub edx, ecx
           mov [pg_data.pages_free], edx
 
           xor eax, eax
           mov ebx, ecx
           shr ecx, 5
           rep stosd
 
           not eax
           mov ecx, ebx
           and ecx, 31
           shl eax, cl
           stosd
 
           mov [page_start], sys_pgmap+512
           mov ebx, sys_pgmap
           add ebx, [pg_data.pagemap_size]
           mov [page_end], ebx
 
           mov [pg_data.pg_mutex], 0
 
           ret
endp
 
align 4
proc alloc_page
 
           pushfd
           cli
           mov ebx, [page_start]
           mov ecx, [page_end]
.l1:
           bsf eax,[ebx];
           jnz .found
           add ebx,4
           cmp ebx, ecx
           jb .l1
           popfd
           xor eax,eax
           ret
.found:
           btr [ebx], eax
           mov [page_start],ebx
           sub ebx, sys_pgmap
           shl ebx, 3
           add eax,ebx
           shl eax, 12
           dec [pg_data.pages_free]
           popfd
           ret
endp
 
align 4
proc alloc_pages stdcall, count:dword
           pushfd
           cli
           mov eax, [count]
           add eax, 7
           shr eax, 3
           mov [count], eax
           cmp eax, [pg_data.pages_free]
           ja .fail
 
           mov ecx, [page_start]
           mov ebx, [page_end]
.find:
           mov edx, [count]
           mov edi, ecx
.match:
           cmp byte [ecx], 0xFF
           jne .next
           dec edx
           jz .ok
           inc ecx
           cmp ecx,ebx
           jb .match
.fail:     xor eax, eax
           popfd
           ret
.next:
           inc ecx
           cmp ecx, ebx
           jb .find
           popfd
           xor eax, eax
           ret
.ok:
           sub ecx, edi
           inc ecx
           mov esi, edi
           xor eax, eax
           rep stosb
           sub esi, sys_pgmap
           shl esi, 3+12
           mov eax, esi
           mov ebx, [count]
           shl ebx, 3
           sub [pg_data.pages_free], ebx
           popfd
           ret
endp
 
align 4
proc map_page stdcall,lin_addr:dword,phis_addr:dword,flags:dword
           mov eax, [phis_addr]
           and eax, not 0xFFF
           or eax, [flags]
           mov ebx, [lin_addr]
           shr ebx, 12
           mov [pages_tab+ebx*4], eax
           mov eax, [lin_addr]
           invlpg [eax]
           ret
endp
 
align 4
proc free_page
;arg:  eax  page address
           pushfd
           cli
           inc [pg_data.pages_free]
           shr eax, 12              ;page index
           mov ebx, sys_pgmap
           bts [ebx], eax           ;that's all!
           shr eax, 3
           and eax, not 3           ;dword offset from page_map
           add eax, ebx
           cmp [page_start], eax
           ja @f
           popfd
           ret
@@:
           mov [page_start], eax
           popfd
           ret
endp
 
align 4
proc map_page_table stdcall, lin_addr:dword, phis_addr:dword
           mov ebx, [lin_addr]
           shr ebx, 22
           mov eax, [phis_addr]
           and eax, not 0xFFF
           or eax, PG_UW          ;+PG_NOCACHE
           mov dword [current_pgdir+ebx*4], eax
           mov eax, [lin_addr]
           shr eax, 10
           add eax, pages_tab
           invlpg [eax]
           ret
endp
 
align 4
proc init_LFB
 
           cmp dword [LFBAddress], -1
           jne @f
 
           mov [0x2f0000+0x901c],byte 2
           stdcall kernel_alloc, 0x280000
           mov [LFBAddress], eax
 
           ret
@@:
           test [SCR_MODE],word 0100000000000000b
           jz @f
           call map_LFB
@@:
           ret
endp
 
align 4
proc map_LFB
           locals
             pg_count dd ?
           endl
 
           mov edi, [LFBSize]
           mov esi, [LFBAddress]
           shr edi, 12
           mov [pg_count], edi
           shr edi, 10
 
           bt [cpu_caps], CAPS_PSE
           jnc .map_page_tables
           mov ebx, esi
           or esi, PG_LARGE+PG_UW
           shr ebx, 20
           mov ecx, ebx
@@:
           mov [sys_pgdir+ebx], esi
           add ebx, 4
           add esi, 0x00400000
           dec edi
           jnz @B
 
           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
 
           stdcall wait_mutex, pg_data.pg_mutex
 
           mov edi, [new_size]
           add edi,4095
           and edi,not 4095
           mov [new_size], edi
 
           mov edx,[CURRENT_TASK]
           shl edx,8
           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]
           mov    [PROC_BASE+0x8c+edx],ebx
 
;search threads and update
;application memory size infomation
           mov    ecx,[PROC_BASE+0xb8+edx]
           mov    eax,2
 
.search_threads:
;eax = current slot
;ebx = new memory size
;ecx = page directory
           cmp    eax,[TASK_COUNT]
           jg     .search_threads_end
           mov    edx,eax
           shl    edx,5
           cmp    word [CURRENT_TASK+edx+0xa],9 ;if slot empty?
           jz     .search_threads_next
           shl    edx,3
           cmp    [PROC_BASE+edx+0xb8],ecx     ;if it is our thread?
           jnz    .search_threads_next
           mov    [PROC_BASE+edx+0x8c],ebx     ;update memory size
.search_threads_next:
           inc    eax
           jmp    .search_threads
.search_threads_end:
           xor eax, eax
           dec [pg_data.pg_mutex]
           ret
 
.expand:
           add edi, new_app_base
           add esi, new_app_base
 
           push esi
           push edi
 
           add edi, 0x3FFFFF
           and edi, not(0x3FFFFF)
           add esi, 0x3FFFFF
           and esi, not(0x3FFFFF)
 
           cmp esi, edi
           jae .grow
 
           xchg esi, edi
 
@@:
           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
           jna @B
 
           jmp .update_size
.exit:
           xor eax, eax
           inc eax
           dec [pg_data.pg_mutex]
           ret
endp
 
align 4
proc get_pg_addr stdcall, lin_addr:dword
           mov ebx, [lin_addr]
           shr ebx, 12
           mov eax, [pages_tab+ebx*4]
           and eax, 0xFFFFF000
           ret
endp
 
align 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_notify, ebx
           ret
@@:
           cmp eax, 15
           ja @f
           mov ecx, [CURRENT_TASK]
           shl ecx, 8
           mov eax, [ecx+PROC_BASE+APPDATA.fpu_handler]
           mov [ecx+PROC_BASE+APPDATA.fpu_handler], ebx
           mov [esp+36], eax
           ret
@@:
           cmp eax, 16
           ja @f
 
           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 @f
           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 fpu_save
           clts
           mov ebx, [fpu_owner]
           shl ebx, 8
           mov eax, [ebx+PROC_BASE+0x10]
           mov ebx, [CURRENT_TASK]
           mov [fpu_owner], ebx
 
           bt [cpu_caps], CAPS_FXSR
           jnc .no_SSE
 
           fxsave [eax]
           fninit            ;re-init fpu
           ret
.no_SSE:
           fnsave [eax]
           ret
endp
 
align 4
proc fpu_restore
           mov ebx, [CURRENT_TASK]
           shl ebx, 8
           mov eax, [ebx+PROC_BASE+0x10]
           bt [cpu_caps], CAPS_FXSR
           jnc .no_SSE
 
           fxrstor [eax]
           ret
.no_SSE:
           fnclex               ;fix possible problems
           frstor [eax]
           ret
endp
 
align 4
proc test_cpu
           locals
              cpu_type   dd ?
              cpu_id     dd ?
              cpu_Intel  dd ?
              cpu_AMD    dd ?
           endl
 
           mov [cpu_type], 0
 
           pushfd
           pop eax
           mov ecx, eax
           xor eax, 0x40000
           push eax
           popfd
           pushfd
           pop eax
           xor eax, ecx
           mov [cpu_type], CPU_386
           jz .end_cpu
           push ecx
           popfd
 
           mov [cpu_type], CPU_486
           mov eax, ecx
           xor eax, 0x200000
           push eax
           popfd
           pushfd
           pop eax
           xor eax, ecx
           je .end_cpu
           mov [cpu_id], 1
 
           xor eax, eax
           cpuid
           mov [cpu_vendor], ebx
           mov [cpu_vendor+4], edx
           mov [cpu_vendor+8], ecx
           cmp ebx, dword [intel_str]
           jne .check_AMD
           cmp edx, dword [intel_str+4]
           jne .check_AMD
           cmp ecx, dword [intel_str+8]
           jne .check_AMD
           mov [cpu_Intel], 1
           cmp eax, 1
           jl .end_cpuid
           mov eax, 1
           cpuid
           mov [cpu_sign], eax
           mov [cpu_info],  ebx
           mov [cpu_caps],  edx
           mov [cpu_caps+4],ecx
 
           shr eax, 8
           and eax, 0x0f
           mov [cpu_type], eax
           ret
 
.end_cpuid:
           mov eax, [cpu_type]
           ret
 
.check_AMD:
           cmp ebx, dword [AMD_str]
           jne .end_cpu
           cmp edx, dword [AMD_str+4]
           jne .end_cpu
           cmp ecx, dword [AMD_str+8]
           jne .end_cpu
           mov [cpu_AMD], 1
           cmp eax, 1
           jl .end_cpuid
           mov eax, 1
           cpuid
           mov [cpu_sign], eax
           mov [cpu_info],  ebx
           mov [cpu_caps],  edx
           mov [cpu_caps+4],ecx
           shr eax, 8
           and eax, 0x0f
           mov [cpu_type], eax
.end_cpu:
           mov eax, [cpu_type]
           ret
endp
 
MEM_WB     equ 6               ;write-back memory
MEM_WC     equ 1               ;write combined memory
MEM_UC     equ 0               ;uncached memory
 
align 4
proc init_mtrr
 
           cmp [0x2f0000+0x901c],byte 2
           je  .exit
 
           mov eax, cr0
           or eax, 0x60000000   ;disable caching
           mov cr0, eax
           wbinvd               ;invalidate cache
 
           mov ecx, 0x2FF
           rdmsr                ;
           push eax
 
           xor edx, edx
           xor eax, eax
           mov ecx, 0x2FF
           wrmsr                ;disable all MTRR
 
           stdcall set_mtrr, dword 0,dword 0,[MEM_AMOUNT],MEM_WB
           stdcall set_mtrr, dword 1,[LFBAddress],[LFBSize],MEM_WC
           xor edx, edx
           xor eax, eax
           mov ecx, 0x204
           mov ebx, 6
@@:
           wrmsr                ;disable unused MTRR
           inc ecx
           wrmsr
           inc ecx
           dec ebx
           jnz @b
 
           wbinvd               ;again invalidate
 
           pop eax
           or eax, 0x800        ;set default memtype to UC
           and al, 0xF0
           mov ecx, 0x2FF
           wrmsr                ;and enable MTRR
 
           mov eax, cr0
           and eax, not 0x60000000
           mov cr0, eax         ; enable caching
.exit:
           ret
endp
 
align 4
proc set_mtrr stdcall, reg:dword,base:dword,size:dword,mem_type:dword
 
           xor edx, edx
           mov eax, [base]
           or eax, [mem_type]
           mov ecx, [reg]
           lea ecx, [0x200+ecx*2]
           wrmsr
 
           mov ebx, [size]
           dec ebx
           mov eax, 0xFFFFFFFF
           mov edx, 0x0000000F
           sub eax, ebx
           sbb edx, 0
           or eax, 0x800
           inc ecx
           wrmsr
           ret
endp
 
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
 
;  current_pdir      rd 1
 
  fpu_data          rd 1
  fdd_buff          rd 1
 
  stall_mcs         rd 1
;;CPUID information
 
  cpu_vendor        rd 3
  cpu_sign          rd 1
  cpu_info          rd 1
 
endg
 
uglobal
align 16
   dll_tab         rb 32*32
   srv_tab         rb 32*32
   dll_map         rd 1
   srv_map         rd 1
 
   mem_used_list   rd 1
   mem_block_list  rd 64
   mem_block_map   rb 512
   mem_block_arr   rd 1
   mem_block_start rd 1
   mem_block_end   rd 1
   mem_block_mask  rd 2
   heap_size       rd 1
   heap_free       rd 1
   heap_blocks     rd 1
   free_blocks     rd 1
 
   page_start      rd 1
   page_end        rd 1
   sys_page_map    rd 1
;   app_load        rd 1
endg
 
 
;     push eax
;     push edx
;     mov edx, 0x400   ;bocsh
;     mov al,0xff      ;bocsh
;     out dx, al       ;bocsh
;     pop edx
;     pop eax

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/memory.inc – Rev 203 → 207