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

Subversion Repositories Kolibri OS

(root)/kernel/branches/flat_kernel/core/memory.inc @ 432 – Rev 207 → 211