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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 1629 $
 
 
align 4
proc alloc_page
 
           pushfd
           cli
           push ebx
;//-
	   cmp [pg_data.pages_free], 1
	   jle .out_of_memory
;//-
 
           mov ebx, [page_start]
           mov ecx, [page_end]
.l1:
           bsf eax,[ebx];
           jnz .found
           add ebx,4
           cmp ebx, ecx
           jb .l1
           pop ebx
           popfd
           xor eax,eax
           ret
.found:
;//-
	   dec [pg_data.pages_free]
	   jz .out_of_memory
;//-
           btr [ebx], eax
           mov [page_start],ebx
           sub ebx, sys_pgmap
           lea eax, [eax+ebx*8]
           shl eax, 12
;//-       dec [pg_data.pages_free]
           pop ebx
           popfd
           ret
;//-
.out_of_memory:
 	   mov [pg_data.pages_free], 1
	   xor eax, eax
	   pop ebx
	   popfd
	   ret
;//-
endp
 
align 4
proc alloc_pages stdcall, count:dword
           pushfd
           push ebx
           push edi
           cli
           mov eax, [count]
           add eax, 7
           shr eax, 3
           mov [count], eax
;//-
           mov ebx, [pg_data.pages_free]
           sub  ebx, 9
           js .out_of_memory
           shr   ebx, 3
           cmp eax, ebx
           jg .out_of_memory
;//-
           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
.out_of_memory:
.fail:
           xor eax, eax
           pop edi
           pop ebx
           popfd
           ret
.next:
           inc ecx
           cmp ecx, ebx
           jb .find
           pop edi
           pop ebx
           popfd
           xor eax, eax
           ret
.ok:
           sub ecx, edi
           inc ecx
           push esi
           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
           pop esi
           pop edi
           pop ebx
           popfd
           ret
endp
 
align 4
proc map_page stdcall,lin_addr:dword,phis_addr:dword,flags:dword
           push ebx
           mov eax, [phis_addr]
           and eax, not 0xFFF
           or eax, [flags]
           mov ebx, [lin_addr]
           shr ebx, 12
           mov [page_tabs+ebx*4], eax
           mov eax, [lin_addr]
           invlpg [eax]
           pop ebx
           ret
endp
 
align 4
map_space:    ;not implemented
 
 
           ret
 
 
align 4
proc free_page
;arg:  eax  page address
           pushfd
           cli
           shr eax, 12                        ;page index
           bts dword [sys_pgmap], eax         ;that's all!
           cmc
           adc [pg_data.pages_free], 0
           shr eax, 3
           and eax, not 3                     ;dword offset from page_map
           add eax, sys_pgmap
           cmp [page_start], eax
           ja @f
           popfd
           ret
@@:
           mov [page_start], eax
           popfd
           ret
endp
 
proc map_io_mem stdcall, base:dword, size:dword, flags:dword
 
           push ebx
           push edi
           mov eax, [size]
           add eax, 4095
           and eax, -4096
           mov [size], eax
           stdcall alloc_kernel_space, eax
           test eax, eax
           jz .fail
           push eax
 
           mov edi, 0x1000
           mov ebx, eax
           mov ecx,[size]
           mov edx, [base]
           shr eax, 12
           shr ecx, 12
           and edx, -4096
           or edx, [flags]
@@:
           mov [page_tabs+eax*4], edx
          ; push eax
           invlpg [ebx]
          ; pop eax
           inc eax
           add ebx, edi
           add edx, edi
           loop @B
 
           pop eax
           mov edx, [base]
           and edx, 4095
           add eax, edx
.fail:
           pop edi
           pop ebx
           ret
endp
 
; param
;  eax= page base + page flags
;  ebx= linear address
;  ecx= count
 
align 4
commit_pages:
           push edi
           test ecx, ecx
           jz .fail
 
           mov edi, ebx
           mov ebx, pg_data.pg_mutex
           call wait_mutex      ;ebx
 
           mov edx, 0x1000
           mov ebx, edi
           shr ebx, 12
@@:
           mov [page_tabs+ebx*4], eax
          ; push eax
           invlpg [edi]
          ; pop eax
           add edi, edx
           add eax, edx
           inc ebx
           dec ecx
           jnz @B
           mov [pg_data.pg_mutex],ecx
.fail:
           pop edi
           ret
 
 
; param
;  eax= base
;  ecx= count
 
align 4
release_pages:
 
           pushad
           mov ebx, pg_data.pg_mutex
           call wait_mutex      ;ebx
 
           mov esi, eax
           mov edi, eax
 
           shr esi, 10
           add esi, page_tabs
 
           mov ebp, [pg_data.pages_free]
           mov ebx, [page_start]
           mov edx, sys_pgmap
@@:
           xor eax, eax
           xchg eax, [esi]
           push eax
           invlpg [edi]
           pop eax
 
           test eax, 1
           jz .next
 
           shr eax, 12
           bts [edx], eax
           cmc
           adc ebp, 0
           shr eax, 3
           and eax, -4
           add eax, edx
           cmp eax, ebx
           jae .next
 
           mov ebx, eax
.next:
           add edi, 0x1000
           add esi, 4
           dec ecx
           jnz @B
           mov [pg_data.pages_free], ebp
           and [pg_data.pg_mutex],0
           popad
           ret
 
; param
;  eax= base
;  ecx= count
 
align 4
unmap_pages:
 
           push edi
 
           mov edi, eax
           mov edx, eax
 
           shr edi, 10
           add edi, page_tabs
 
           xor eax, eax
@@:
           stosd
           invlpg [edx]
           add edx, 0x1000
           loop @b
 
           pop edi
           ret
 
 
align 4
proc map_page_table stdcall, lin_addr:dword, phis_addr:dword
           push ebx
           mov ebx, [lin_addr]
           shr ebx, 22
           mov eax, [phis_addr]
           and eax, not 0xFFF
           or eax, PG_UW          ;+PG_NOCACHE
           mov dword [master_tab+ebx*4], eax
           mov eax, [lin_addr]
           shr eax, 10
           add eax, page_tabs
           invlpg [eax]
           pop ebx
           ret
endp
 
align 4
proc init_LFB
           locals
             pg_count dd ?
           endl
 
           cmp dword [LFBAddress], -1
           jne @f
           mov [BOOT_VAR+0x901c],byte 2
           stdcall alloc_pages, (0x280000 / 4096)
 
           push eax
           call alloc_page
           stdcall map_page_table, LFB_BASE, eax
           pop eax
           or eax, PG_UW
           mov ebx, LFB_BASE
           mov ecx, 0x280000 / 4096
           call commit_pages
           mov [LFBAddress], dword LFB_BASE
           ret
@@:
           test [SCR_MODE],word 0100000000000000b
           jnz @f
           mov [BOOT_VAR+0x901c],byte 2
           ret
@@:
           call init_mtrr
 
           mov edx, LFB_BASE
           mov esi, [LFBAddress]
           mov edi, 0x00C00000
           mov dword [exp_lfb+4], edx
 
           shr edi, 12
           mov [pg_count], edi
           shr edi, 10
 
           bt [cpu_caps], CAPS_PSE
           jnc .map_page_tables
           or esi, PG_LARGE+PG_UW
           mov edx, sys_pgdir+(LFB_BASE shr 20)
@@:
           mov [edx], esi
           add edx, 4
           add esi, 0x00400000
           dec edi
           jnz @B
 
           bt [cpu_caps], CAPS_PGE
           jnc @F
           or dword [sys_pgdir+(LFB_BASE shr 20)], PG_GLOBAL
@@:
           mov dword [LFBAddress], LFB_BASE
           mov eax, cr3       ;flush TLB
           mov cr3, eax
           ret
 
.map_page_tables:
 
@@:
           call alloc_page
           stdcall map_page_table, edx, eax
           add edx, 0x00400000
           dec edi
           jnz @B
 
           mov eax, [LFBAddress]
           mov edi, page_tabs + (LFB_BASE shr 10)
           or eax, PG_UW
           mov ecx, [pg_count]
           cld
@@:
           stosd
           add eax, 0x1000
           dec ecx
           jnz @B
 
           mov dword [LFBAddress], LFB_BASE
           mov eax, cr3       ;flush TLB
           mov cr3, eax
 
           ret
endp
 
align 4
proc new_mem_resize stdcall, new_size:dword
 
           mov ebx, pg_data.pg_mutex
           call wait_mutex    ;ebx
 
           mov edi, [new_size]
           add edi,4095
           and edi,not 4095
           mov [new_size], edi
 
           mov edx,[current_slot]
           cmp [edx+APPDATA.heap_base],0
           jne .exit
 
           mov esi, [edx+APPDATA.mem_size]
           add esi, 4095
           and esi, not 4095
 
           cmp edi, esi
           jae .expand
 
           shr edi, 12
           shr esi, 12
@@:
           mov eax, [app_page_tabs+edi*4]
           test eax, 1
           jz .next
           mov dword [app_page_tabs+edi*4], 2
           mov ebx, edi
           shl ebx, 12
           push eax
           invlpg [ebx]
           pop eax
           call free_page
 
.next:     add edi, 1
           cmp edi, esi
           jb @B
 
.update_size:
           mov     ebx, [new_size]
           call    update_mem_size
 
           xor eax, eax
           dec [pg_data.pg_mutex]
           ret
.expand:
 
           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_pop
 
           stdcall map_page_table, edi, eax
 
           push edi
           shr edi, 10
           add edi, page_tabs
           mov ecx, 1024
           xor eax, eax
           cld
           rep stosd
           pop edi
 
           add edi, 0x00400000
           cmp edi, esi
           jb @B
.grow:
;//-
	   pop edi
	   push edi
	   mov esi, [pg_data.pages_free]
	   sub esi, 1
	   shr edi, 12
	   cmp esi, edi
	   jle .out_of_memory
;//-
           pop edi
           pop esi
@@:
           call alloc_page
           test eax, eax
           jz .exit
           stdcall map_page,esi,eax,dword PG_UW
 
           push edi
           mov edi, esi
           xor eax, eax
           mov ecx, 1024
           cld
           rep stosd
           pop edi
 
           add esi, 0x1000
           cmp esi, edi
           jb  @B
 
           jmp .update_size
;//-
.exit_pop:
.out_of_memory:
;//-
           pop edi
           pop esi
.exit:
           xor eax, eax
           inc eax
           dec [pg_data.pg_mutex]
           ret
endp
 
update_mem_size:
; in: edx = slot base
;     ebx = new memory size
; destroys eax,ecx,edx
 
           mov    [APPDATA.mem_size+edx],ebx
;search threads and update
;application memory size infomation
           mov    ecx,[APPDATA.dir_table+edx]
           mov    eax,2
 
.search_threads:
;eax = current slot
;ebx = new memory size
;ecx = page directory
           cmp    eax,[TASK_COUNT]
           jg     .search_threads_end
           mov    edx,eax
           shl    edx,5
           cmp    word [CURRENT_TASK+edx+TASKDATA.state],9 ;if slot empty?
           jz     .search_threads_next
           shl    edx,3
           cmp    [SLOT_BASE+edx+APPDATA.dir_table],ecx     ;if it is our thread?
           jnz    .search_threads_next
           mov    [SLOT_BASE+edx+APPDATA.mem_size],ebx     ;update memory size
.search_threads_next:
           inc    eax
           jmp    .search_threads
.search_threads_end:
           ret
 
; param
;  eax= linear address
;
; retval
;  eax= phisical page address
 
align 4
get_pg_addr:
           shr eax, 12
           mov eax, [page_tabs+eax*4]
           and eax, 0xFFFFF000
           ret
 
 
align 4
; Now it is called from core/sys32::exc_c (see stack frame there)
proc page_fault_handler
 
    .err_addr   equ ebp-4
 
        push    ebx               ;save exception number (#PF)
        mov     ebp, esp
        mov     ebx, cr2
        push    ebx               ;that is locals: .err_addr = cr2
        inc     [pg_data.pages_faults]
 
        mov     eax, [pf_err_code]
 
        cmp     ebx, OS_BASE      ;ebx == .err_addr
        jb      .user_space       ;ñòðàíèöà â ïàìÿòè ïðèëîæåíèÿ ;
 
        cmp     ebx, page_tabs
        jb      .kernel_space     ;ñòðàíèöà â ïàìÿòè ÿäðà
 
        cmp     ebx, kernel_tabs
        jb      .alloc;.app_tabs  ;òàáëèöû ñòðàíèö ïðèëîæåíèÿ ;
                                  ;ïðîñòî ñîçäàäèì îäíó
if 0 ;ïîêà ýòî ïðîñòî ëèøíåå
        cmp     ebx, LFB_BASE
        jb      .core_tabs        ;òàáëèöû ñòðàíèö ÿäðà
                                  ;Îøèáêà
  .lfb:
                                  ;îáëàñòü LFB
                                  ;Îøèáêà
        jmp     .fail
end if
.core_tabs:
.fail:  ;simply return to caller
        mov     esp, ebp
        pop     ebx               ;restore exception number (#PF)
        ret
 
;        xchg bx, bx
;        add     esp,12 ;clear in stack: locals(.err_addr) + #PF + ret_to_caller
;        restore_ring3_context
;        iretd
 
.user_space:
        test    eax, PG_MAP
        jnz     .err_access       ;Ñòðàíèöà ïðèñóòñòâóåò
                                  ;Îøèáêà äîñòóïà ?
 
        shr     ebx, 12
        mov     ecx, ebx
        shr     ecx, 10
        mov     edx, [master_tab+ecx*4]
        test    edx, PG_MAP
        jz      .fail             ;òàáëèöà ñòðàíèö íå ñîçäàíà
                                  ;íåâåðíûé àäðåñ â ïðîãðàììå
 
        mov     eax, [page_tabs+ebx*4]
        test    eax, 2
        jz      .fail             ;àäðåñ íå çàðåçåðâèðîâàí äëÿ ;
                                  ;èñïîëüçîâàíèÿ. Îøèáêà
.alloc:
        call    alloc_page
        test    eax, eax
        jz      .fail
 
        stdcall map_page,[.err_addr],eax,PG_UW
 
        mov     edi, [.err_addr]
        and     edi, 0xFFFFF000
        mov     ecx, 1024
        xor     eax, eax
       ;cld     ;caller is duty for this
        rep     stosd
.exit:  ;iret with repeat fault instruction
        add     esp,12 ;clear in stack: locals(.err_addr) + #PF + ret_to_caller
        restore_ring3_context
        iretd
 
.err_access:
; access denied? this may be a result of copy-on-write protection for DLL
; check list of HDLLs
        and     ebx, not 0xFFF
        mov     eax, [CURRENT_TASK]
        shl     eax, 8
        mov     eax, [SLOT_BASE+eax+APPDATA.dlls_list_ptr]
        test    eax, eax
        jz      .fail
        mov     esi, [eax+HDLL.fd]
.scan_hdll:
        cmp     esi, eax
        jz      .fail
        mov     edx, ebx
        sub     edx, [esi+HDLL.base]
        cmp     edx, [esi+HDLL.size]
        jb      .fault_in_hdll
.scan_hdll.next:
        mov     esi, [esi+HDLL.fd]
        jmp     .scan_hdll
.fault_in_hdll:
; allocate new page, map it as rw and copy data
        call    alloc_page
        test    eax, eax
        jz      .fail
        stdcall map_page,ebx,eax,PG_UW
        mov     edi, ebx
        mov     ecx, 1024
        sub     ebx, [esi+HDLL.base]
        mov     esi, [esi+HDLL.parent]
        mov     esi, [esi+DLLDESCR.data]
        add     esi, ebx
        rep     movsd
        jmp     .exit
 
.kernel_space:
        test    eax, PG_MAP
        jz      .fail   ;ñòðàíèöà íå ïðèñóòñòâóåò
 
        test    eax,12  ;U/S (+below)
        jnz     .fail   ;ïðèëîæåíèå îáðàòèëîñü ê ïàìÿòè
                        ;ÿäðà
       ;test    eax, 8
       ;jnz     .fail   ;óñòàíîâëåí çàðåçåðâèðîâàííûé áèò
                        ;â òàáëèöàõ ñòðàíèö. äîáàâëåíî â P4/Xeon
 
;ïîïûòêà çàïèñè â çàùèù¸ííóþ ñòðàíèöó ÿäðà
 
        cmp     ebx, tss._io_map_0
        jb      .fail
 
        cmp     ebx, tss._io_map_0+8192
        jae     .fail
 
; io permission map
; copy-on-write protection
 
        call    alloc_page
        test    eax, eax
        jz      .fail
 
        push    eax
        stdcall map_page,[.err_addr],eax,dword PG_SW
        pop     eax
        mov     edi, [.err_addr]
        and     edi, -4096
        lea     esi, [edi+(not tss._io_map_0)+1]; -tss._io_map_0
 
        mov     ebx, esi
        shr     ebx, 12
        mov     edx, [current_slot]
        or      eax, PG_SW
        mov     [edx+APPDATA.io_map+ebx*4], eax
 
        add     esi, [default_io_map]
        mov     ecx, 4096/4
       ;cld     ;caller is duty for this
        rep     movsd
        jmp     .exit
endp
 
; returns number of mapped bytes
proc map_mem stdcall, lin_addr:dword,slot:dword,\
                      ofs:dword,buf_size:dword,req_access:dword
           push 0 ; initialize number of mapped bytes
 
           cmp [buf_size], 0
           jz .exit
 
           mov eax, [slot]
           shl eax, 8
           mov eax, [SLOT_BASE+eax+APPDATA.dir_table]
           and eax, 0xFFFFF000
 
           stdcall map_page,[ipc_pdir],eax,PG_UW
           mov ebx, [ofs]
           shr ebx, 22
           mov esi, [ipc_pdir]
           mov edi, [ipc_ptab]
           mov eax, [esi+ebx*4]
           and eax, 0xFFFFF000
           jz .exit
           stdcall map_page,edi,eax,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:
           stdcall safe_map_page,[slot],[req_access],[ofs]
           jnc .exit
           add dword [ebp-4], 4096
           add [ofs], 4096
           dec ecx
           jz  .exit
           add edi, 0x1000
           inc edx
           cmp edx, 0x400
           jnz .map
           inc ebx
           mov eax, [ipc_pdir]
           mov eax, [eax+ebx*4]
           and eax, 0xFFFFF000
           jz  .exit
           stdcall map_page,esi,eax,PG_UW
           xor edx, edx
           jmp .map
 
.exit:
           pop eax
           ret
endp
 
proc map_memEx stdcall, lin_addr:dword,slot:dword,\
                        ofs:dword,buf_size:dword,req_access:dword
           push 0 ; initialize number of mapped bytes
 
           cmp [buf_size], 0
           jz .exit
 
           mov eax, [slot]
           shl eax, 8
           mov eax, [SLOT_BASE+eax+APPDATA.dir_table]
           and eax, 0xFFFFF000
 
           stdcall map_page,[proc_mem_pdir],eax,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,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:
           stdcall safe_map_page,[slot],[req_access],[ofs]
           jnc .exit
           add dword [ebp-4], 0x1000
           add edi, 0x1000
           add [ofs], 0x1000
           inc edx
           dec ecx
           jnz .map
.exit:
           pop eax
           ret
endp
 
; in: esi+edx*4 = pointer to page table entry
; in: [slot], [req_access], [ofs] on the stack
; in: edi = linear address to map
; out: CF cleared <=> failed
; destroys: only eax
proc safe_map_page stdcall, slot:dword, req_access:dword, ofs:dword
	mov	eax, [esi+edx*4]
	test	al, PG_MAP
	jz	.not_present
	test	al, PG_WRITE
	jz	.resolve_readonly
; normal case: writable page, just map with requested access
.map:
	stdcall	map_page, edi, eax, [req_access]
	stc
.fail:
	ret
.not_present:
; check for alloc-on-demand page
	test	al, 2
	jz	.fail
; allocate new page, save it to source page table
	push	ecx
	call	alloc_page
	pop	ecx
	test	eax, eax
	jz	.fail
	or	al, PG_UW
	mov	[esi+edx*4], eax
	jmp	.map
.resolve_readonly:
; readonly page, probably copy-on-write
; check: readonly request of readonly page is ok
	test	[req_access], PG_WRITE
	jz	.map
; find control structure for this page
	pushf
	cli
	cld
	push	ebx ecx
	mov	eax, [slot]
	shl	eax, 8
	mov	eax, [SLOT_BASE+eax+APPDATA.dlls_list_ptr]
	test	eax, eax
	jz	.no_hdll
	mov	ecx, [eax+HDLL.fd]
.scan_hdll:
	cmp	ecx, eax
	jz	.no_hdll
	mov	ebx, [ofs]
	and	ebx, not 0xFFF
	sub	ebx, [ecx+HDLL.base]
	cmp	ebx, [ecx+HDLL.size]
	jb	.hdll_found
	mov	ecx, [ecx+HDLL.fd]
	jmp	.scan_hdll
.no_hdll:
	pop	ecx ebx
	popf
	clc
	ret
.hdll_found:
; allocate page, save it in page table, map it, copy contents from base
	mov	eax, [ecx+HDLL.parent]
	add	ebx, [eax+DLLDESCR.data]
	call	alloc_page
	test	eax, eax
	jz	.no_hdll
	or	al, PG_UW
	mov	[esi+edx*4], eax
	stdcall	map_page, edi, eax, [req_access]
	push	esi edi
	mov	esi, ebx
	mov	ecx, 4096/4
	rep	movsd
	pop	edi esi
	pop	ecx ebx
	popf
	stc
	ret
endp
 
sys_IPC:
;input:
;  ebx=1 - set ipc buffer area
;    ecx=address of buffer
;    edx=size of buffer
;  eax=2 - send message
;    ebx=PID
;    ecx=address of message
;    edx=size of message
 
	dec	ebx
	jnz	@f
 
	mov  	eax,[current_slot]
        pushf
        cli
        mov  	[eax+APPDATA.ipc_start],ecx     ;set fields in extended information area
        mov  	[eax+APPDATA.ipc_size],edx
 
        add edx, ecx
        add edx, 4095
        and edx, not 4095
 
.touch: mov eax, [ecx]
        add ecx, 0x1000
        cmp ecx, edx
        jb  .touch
 
        popf
        mov [esp+32], ebx	;ebx=0
        ret
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;2
@@:
	dec	ebx
	jnz	@f
 
        stdcall sys_ipc_send, ecx, edx, esi
        mov 	[esp+32], eax
        ret
@@:
	or	eax,-1
        mov 	[esp+32], eax
        ret
 
;align 4
;proc set_ipc_buff
 
;           mov  eax,[current_slot]
;           pushf
;           cli
;           mov  [eax+APPDATA.ipc_start],ebx     ;set fields in extended information area
;           mov  [eax+APPDATA.ipc_size],ecx
;
;           add ecx, ebx
;           add ecx, 4095
;           and ecx, not 4095
;
;.touch:    mov eax, [ebx]
;           add ebx, 0x1000
;           cmp ebx, ecx
;           jb  .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 ?
             used_buf   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+SLOT_BASE+0xa0]  ;is ipc area defined?
           test edi,edi
           jz   .no_ipc_area
 
           mov ebx, edi
           and ebx, 0xFFF
           mov [dst_offset], ebx
 
           mov esi, [eax+SLOT_BASE+0xa4]
           mov [buf_size], esi
 
           mov ecx, [ipc_tmp]
           cmp esi, 0x40000-0x1000 ; size of [ipc_tmp] minus one page
           jbe @f
           push esi edi
           add esi,0x1000
           stdcall alloc_kernel_space,esi
           mov ecx, eax
           pop edi esi
@@:
           mov [used_buf], ecx
           stdcall map_mem, ecx, [dst_slot],\
                             edi, esi, PG_SW
 
           mov edi, [dst_offset]
           add edi, [used_buf]
           cmp dword [edi], 0
           jnz  .ipc_blocked          ;if dword [buffer]<>0 - ipc blocked now
 
           mov edx, dword [edi+4]
           lea ebx, [edx+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
           add edi, edx
           mov [edi], eax
           mov ecx, [msg_size]
 
           mov [edi+4], ecx
           add edi, 8
           mov esi, [msg_addr]
       ;    add esi, new_app_base
           cld
           rep movsb
 
           mov ebx, [ipc_tmp]
           mov edx, ebx
           shr ebx, 12
           xor eax, eax
           mov [page_tabs+ebx*4], eax
           invlpg [edx]
 
           mov ebx, [ipc_pdir]
           mov edx, ebx
           shr ebx, 12
           xor eax, eax
           mov [page_tabs+ebx*4], eax
           invlpg [edx]
 
           mov ebx, [ipc_ptab]
           mov edx, ebx
           shr ebx, 12
           xor eax, eax
           mov [page_tabs+ebx*4], eax
           invlpg [edx]
 
           mov  eax, [dst_slot]
           shl eax, 8
           or   [eax+SLOT_BASE+0xA8],dword 0x40
           cmp  dword [check_idle_semaphore],20
           jge  .ipc_no_cis
 
           mov  dword [check_idle_semaphore],5
.ipc_no_cis:
           push 0
           jmp .ret
.no_pid:
           popf
           mov eax, 4
           ret
.no_ipc_area:
           popf
           xor eax, eax
           inc eax
           ret
.ipc_blocked:
           push 2
           jmp .ret
.buffer_overflow:
           push 3
.ret:
           mov eax, [used_buf]
           cmp eax, [ipc_tmp]
           jz @f
           stdcall free_kernel_space,eax
@@:
           pop eax
           popf
           ret
endp
 
align 4
sysfn_meminfo:
 
        ;   add ecx, new_app_base
           cmp ecx, OS_BASE
           jae .fail
 
           mov eax, [pg_data.pages_count]
           mov [ecx], eax
           shl eax, 12
           mov [esp+32], eax
           mov eax, [pg_data.pages_free]
           mov [ecx+4], eax
           mov eax, [pg_data.pages_faults]
           mov [ecx+8], eax
           mov eax, [heap_size]
           mov [ecx+12], eax
           mov eax, [heap_free]
           mov [ecx+16], eax
           mov eax, [heap_blocks]
           mov [ecx+20], eax
           mov eax, [free_blocks]
           mov [ecx+24], eax
           ret
.fail:
           or dword [esp+32], -1
           ret
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
align 4
f68:
           cmp  ebx,4
           jbe  sys_sheduler
 
           cmp ebx, 11
           jb .fail
 
           cmp ebx, 25
           ja .fail
 
           jmp dword [f68call+ebx*4-11*4]
.11:
           call init_heap
           mov [esp+32], eax
           ret
.12:
           stdcall user_alloc, ecx
           mov [esp+32], eax
           ret
.13:
           stdcall user_free, ecx
           mov [esp+32], eax
           ret
.14:
           cmp ecx, OS_BASE
           jae .fail
           mov edi,ecx
           call get_event_ex
           mov [esp+32], eax
           ret
.16:
           test ecx, ecx
           jz .fail
           cmp ecx, OS_BASE
           jae .fail
           stdcall get_service, ecx
           mov [esp+32], eax
           ret
.17:
           call srv_handlerEx   ;ecx
           mov [esp+32], eax
           ret
.19:
           cmp ecx, OS_BASE
           jae .fail
           stdcall load_library, ecx
           mov [esp+32], eax
           ret
.20:
           mov     eax, edx
           mov     ebx, ecx
           call    user_realloc		;in: eax = pointer, ebx = new size
           mov     [esp+32], eax
           ret
.21:
           cmp ecx, OS_BASE
           jae .fail
 
           cmp ebx, OS_BASE
           jae .fail
 
           mov edi, edx
           stdcall load_PE, ecx
           mov esi, eax
           test eax, eax
           jz @F
 
           push edi
           push DRV_ENTRY
           call eax
           add esp, 8
           test eax, eax
           jz @F
 
           mov [eax+SRV.entry], esi
 
@@:
           mov [esp+32], eax
           ret
.22:
           cmp ecx, OS_BASE
           jae .fail
 
           stdcall shmem_open, ecx, edx, esi
           mov [esp+24], edx
           mov [esp+32], eax
           ret
 
.23:
           cmp ecx, OS_BASE
           jae .fail
 
           stdcall shmem_close, ecx
           mov [esp+32], eax
           ret
.24:
           mov  eax, [current_slot]
           xchg ecx, [eax+APPDATA.exc_handler]
           xchg edx, [eax+APPDATA.except_mask]
           mov  [esp+32], ecx ; reg_eax+8
           mov  [esp+20], edx ; reg_ebx+8
           ret
.25:
           cmp ecx,32
           jae .fail
           mov  eax, [current_slot]
           btr  [eax+APPDATA.except_mask],ecx
           setc byte[esp+32]
           jecxz @f
           bts  [eax+APPDATA.except_mask],ecx
@@:
           ret
 
.fail:
           xor eax, eax
           mov [esp+32], eax
           ret
 
 
align 4
f68call:   ; keep this table closer to main code
 
           dd f68.11   ; init_heap
           dd f68.12   ; user_alloc
           dd f68.13   ; user_free
           dd f68.14   ; get_event_ex
           dd f68.fail ; moved to f68.24
           dd f68.16   ; get_service
           dd f68.17   ; call_service
           dd f68.fail ; moved to f68.25
           dd f68.19   ; load_dll
           dd f68.20   ; user_realloc
           dd f68.21   ; load_driver
           dd f68.22   ; shmem_open
           dd f68.23   ; shmem_close
           dd f68.24
           dd f68.25
 
 
align 4
proc load_pe_driver stdcall, file:dword
 
           stdcall load_PE, [file]
           test eax, eax
           jz .fail
 
           mov esi, eax
           stdcall eax, DRV_ENTRY
           test eax, eax
           jz .fail
 
           mov [eax+SRV.entry], esi
           ret
 
.fail:
           xor eax, eax
           ret
endp
 
 
align 4
proc init_mtrr
 
           cmp [BOOT_VAR+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                ;
; has BIOS already initialized MTRRs?
           test ah, 8
           jnz .skip_init
; rarely needed, so mainly placeholder
; main memory - cached
           push eax
 
           mov eax, [MEM_AMOUNT]
; round eax up to next power of 2
           dec eax
           bsr ecx, eax
           mov ebx, 2
           shl ebx, cl
           dec ebx
; base of memory range = 0, type of memory range = MEM_WB
           xor edx, edx
           mov eax, MEM_WB
           mov ecx, 0x200
           wrmsr
; mask of memory range = 0xFFFFFFFFF - (size - 1), ebx = size - 1
           mov eax, 0xFFFFFFFF
           mov edx, 0x0000000F
           sub eax, ebx
           sbb edx, 0
           or eax, 0x800
           inc ecx
           wrmsr
; clear unused MTRRs
           xor eax, eax
           xor edx, edx
@@:
           wrmsr
           inc ecx
           cmp ecx, 0x210
           jb @b
; enable MTRRs
           pop eax
           or ah, 8
           and al, 0xF0 ; default memtype = UC
           mov ecx, 0x2FF
           wrmsr
.skip_init:
           stdcall set_mtrr, [LFBAddress],[LFBSize],MEM_WC
 
           wbinvd               ;again invalidate
 
           mov eax, cr0
           and eax, not 0x60000000
           mov cr0, eax         ; enable caching
.exit:
           ret
endp
 
align 4
proc set_mtrr stdcall, base:dword,size:dword,mem_type:dword
; find unused register
           mov ecx, 0x201
@@:
           rdmsr
           dec ecx
           test ah, 8
           jz .found
           rdmsr
           mov al, 0 ; clear memory type field
           cmp eax, [base]
           jz .ret
           add ecx, 3
           cmp ecx, 0x210
           jb @b
; no free registers, ignore the call
.ret:
           ret
.found:
; found, write values
           xor edx, edx
           mov eax, [base]
           or eax, [mem_type]
           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
 
align 4
proc create_ring_buffer stdcall, size:dword, flags:dword
           locals
             buf_ptr  dd ?
           endl
 
           mov eax, [size]
           test eax, eax
           jz .fail
 
           add eax, eax
           stdcall alloc_kernel_space, eax
           test eax, eax
           jz .fail
 
           push ebx
 
           mov [buf_ptr], eax
 
           mov ebx, [size]
           shr ebx, 12
           push ebx
 
           stdcall alloc_pages, ebx
           pop ecx
 
           test eax, eax
           jz .mm_fail
 
           push edi
 
           or eax, [flags]
           mov edi, [buf_ptr]
           mov ebx, [buf_ptr]
           mov edx, ecx
           shl edx, 2
           shr edi, 10
@@:
           mov [page_tabs+edi], eax
           mov [page_tabs+edi+edx], eax
           invlpg [ebx]
           invlpg [ebx+0x10000]
           add eax, 0x1000
           add ebx, 0x1000
           add edi, 4
           dec ecx
           jnz @B
 
           mov eax, [buf_ptr]
           pop edi
           pop ebx
           ret
.mm_fail:
           stdcall free_kernel_space, [buf_ptr]
           xor eax, eax
           pop ebx
.fail:
           ret
endp

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/memory.inc – Rev 1517 → 1629