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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 1689 $
 
 
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
	   call init_mtrr
 
	   mov edx, LFB_BASE
	   mov esi, [LFBAddress]
	   mov edi, 0x00C00000		     ; 12Mb
	   mov dword [exp_lfb+4], edx
 
	   shr edi, 12			     ; C00
	   shr edi, 10			     ; 3
 
	   or esi,  PG_GLOBAL+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
 
	   mov dword [LFBAddress], LFB_BASE
	   mov eax, cr3       ;flush TLB
	   mov cr3, eax
	   ret
endp
 
align 4
init_userDMA:
	   stdcall alloc_pages, 4096	; 16M <<<<<<<<<<+++++++++++++++++++++++++++++++++
	   add eax, 0x007FFFF0		; terrible mess, sorry ...
	   and eax, 0xFF800000		; align at 8M boundary
	   mov [UserDMAaddr], eax
	   or  eax, PG_LARGE + PG_UW + PG_NOCACHE
	   mov ebx, sys_pgdir + (USER_DMA_BUFFER shr 20)
	   mov [ebx], eax
	   add ebx, 4
	   add eax, 0x00400000
	   mov [ebx], eax
	   mov eax, cr3       ;flush TLB
	   mov cr3, eax
	   ret
 
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= physical 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	;ïðèëîæåíèå îáðàòèëîñü ê ïàìÿòè
			;ÿäðà
 
;ïîïûòêà çàïèñè â çàùèù¸ííóþ ñòðàíèöó ÿäðà
	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
 
	   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
 
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:
	   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 1687	Rev 1689
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: 1687 $	8	$Revision: 1689 $
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	call init_mtrr	340	call init_mtrr
341		341
342	mov edx, LFB_BASE	342	mov edx, LFB_BASE
343	mov esi, [LFBAddress]	343	mov esi, [LFBAddress]
344	mov edi, 0x00C00000 ; 12Mb	344	mov edi, 0x00C00000 ; 12Mb
345	mov dword [exp_lfb+4], edx	345	mov dword [exp_lfb+4], edx
346		346
347	shr edi, 12 ; C00	347	shr edi, 12 ; C00
348	shr edi, 10 ; 3	348	shr edi, 10 ; 3
349		349
350	or esi, PG_GLOBAL+PG_LARGE+PG_UW	350	or esi, PG_GLOBAL+PG_LARGE+PG_UW
351	mov edx, sys_pgdir+(LFB_BASE shr 20)	351	mov edx, sys_pgdir+(LFB_BASE shr 20)
352	@@:	352	@@:
353	mov [edx], esi	353	mov [edx], esi
354	add edx, 4	354	add edx, 4
355	add esi, 0x00400000	355	add esi, 0x00400000
356	dec edi	356	dec edi
357	jnz @B	357	jnz @B
358		358
359	mov dword [LFBAddress], LFB_BASE	359	mov dword [LFBAddress], LFB_BASE
360	mov eax, cr3 ;flush TLB	360	mov eax, cr3 ;flush TLB
361	mov cr3, eax	361	mov cr3, eax
362	ret	362	ret
363	endp	363	endp
364		364
365	align 4	365	align 4
366	init_userDMA:	366	init_userDMA:
367	stdcall alloc_pages, 4096 ; 16M <<<<<<<<<<+++++++++++++++++++++++++++++++++	367	stdcall alloc_pages, 4096 ; 16M <<<<<<<<<<+++++++++++++++++++++++++++++++++
368	add eax, 0x007FFFF0 ; terrible mess, sorry ...	368	add eax, 0x007FFFF0 ; terrible mess, sorry ...
369	and eax, 0xFF800000 ; align at 8M boundary	369	and eax, 0xFF800000 ; align at 8M boundary
370	mov [UserDMAaddr], eax	370	mov [UserDMAaddr], eax
371	or eax, PG_LARGE + PG_UW + PG_NOCACHE	371	or eax, PG_LARGE + PG_UW + PG_NOCACHE
372	mov ebx, sys_pgdir + (USER_DMA_BUFFER shr 20)	372	mov ebx, sys_pgdir + (USER_DMA_BUFFER shr 20)
373	mov [ebx], eax	373	mov [ebx], eax
374	add ebx, 4	374	add ebx, 4
375	add eax, 0x00400000	375	add eax, 0x00400000
376	mov [ebx], eax	376	mov [ebx], eax
377	mov eax, cr3 ;flush TLB	377	mov eax, cr3 ;flush TLB
378	mov cr3, eax	378	mov cr3, eax
379	ret	379	ret
380		380
381	align 4	381	align 4
382	proc new_mem_resize stdcall, new_size:dword	382	proc new_mem_resize stdcall, new_size:dword
383		383
384	mov ebx, pg_data.pg_mutex	384	mov ebx, pg_data.pg_mutex
385	call wait_mutex ;ebx	385	call wait_mutex ;ebx
386		386
387	mov edi, [new_size]	387	mov edi, [new_size]
388	add edi,4095	388	add edi,4095
389	and edi,not 4095	389	and edi,not 4095
390	mov [new_size], edi	390	mov [new_size], edi
391		391
392	mov edx,[current_slot]	392	mov edx,[current_slot]
393	cmp [edx+APPDATA.heap_base],0	393	cmp [edx+APPDATA.heap_base],0
394	jne .exit	394	jne .exit
395		395
396	mov esi, [edx+APPDATA.mem_size]	396	mov esi, [edx+APPDATA.mem_size]
397	add esi, 4095	397	add esi, 4095
398	and esi, not 4095	398	and esi, not 4095
399		399
400	cmp edi, esi	400	cmp edi, esi
401	jae .expand	401	jae .expand
402		402
403	shr edi, 12	403	shr edi, 12
404	shr esi, 12	404	shr esi, 12
405	@@:	405	@@:
406	mov eax, [app_page_tabs+edi*4]	406	mov eax, [app_page_tabs+edi*4]
407	test eax, 1	407	test eax, 1
408	jz .next	408	jz .next
409	mov dword [app_page_tabs+edi*4], 2	409	mov dword [app_page_tabs+edi*4], 2
410	mov ebx, edi	410	mov ebx, edi
411	shl ebx, 12	411	shl ebx, 12
412	push eax	412	push eax
413	invlpg [ebx]	413	invlpg [ebx]
414	pop eax	414	pop eax
415	call free_page	415	call free_page
416		416
417	.next: add edi, 1	417	.next: add edi, 1
418	cmp edi, esi	418	cmp edi, esi
419	jb @B	419	jb @B
420		420
421	.update_size:	421	.update_size:
422	mov ebx, [new_size]	422	mov ebx, [new_size]
423	call update_mem_size	423	call update_mem_size
424		424
425	xor eax, eax	425	xor eax, eax
426	dec [pg_data.pg_mutex]	426	dec [pg_data.pg_mutex]
427	ret	427	ret
428	.expand:	428	.expand:
429		429
430	push esi	430	push esi
431	push edi	431	push edi
432		432
433	add edi, 0x3FFFFF	433	add edi, 0x3FFFFF
434	and edi, not(0x3FFFFF)	434	and edi, not(0x3FFFFF)
435	add esi, 0x3FFFFF	435	add esi, 0x3FFFFF
436	and esi, not(0x3FFFFF)	436	and esi, not(0x3FFFFF)
437		437
438	cmp esi, edi	438	cmp esi, edi
439	jae .grow	439	jae .grow
440		440
441	xchg esi, edi	441	xchg esi, edi
442		442
443	@@:	443	@@:
444	call alloc_page	444	call alloc_page
445	test eax, eax	445	test eax, eax
446	jz .exit_pop	446	jz .exit_pop
447		447
448	stdcall map_page_table, edi, eax	448	stdcall map_page_table, edi, eax
449		449
450	push edi	450	push edi
451	shr edi, 10	451	shr edi, 10
452	add edi, page_tabs	452	add edi, page_tabs
453	mov ecx, 1024	453	mov ecx, 1024
454	xor eax, eax	454	xor eax, eax
455	cld	455	cld
456	rep stosd	456	rep stosd
457	pop edi	457	pop edi
458		458
459	add edi, 0x00400000	459	add edi, 0x00400000
460	cmp edi, esi	460	cmp edi, esi
461	jb @B	461	jb @B
462	.grow:	462	.grow:
463	;//-	463	;//-
464	pop edi	464	pop edi
465	push edi	465	push edi
466	mov esi, [pg_data.pages_free]	466	mov esi, [pg_data.pages_free]
467	sub esi, 1	467	sub esi, 1
468	shr edi, 12	468	shr edi, 12
469	cmp esi, edi	469	cmp esi, edi
470	jle .out_of_memory	470	jle .out_of_memory
471	;//-	471	;//-
472	pop edi	472	pop edi
473	pop esi	473	pop esi
474	@@:	474	@@:
475	call alloc_page	475	call alloc_page
476	test eax, eax	476	test eax, eax
477	jz .exit	477	jz .exit
478	stdcall map_page,esi,eax,dword PG_UW	478	stdcall map_page,esi,eax,dword PG_UW
479		479
480	push edi	480	push edi
481	mov edi, esi	481	mov edi, esi
482	xor eax, eax	482	xor eax, eax
483	mov ecx, 1024	483	mov ecx, 1024
484	cld	484	cld
485	rep stosd	485	rep stosd
486	pop edi	486	pop edi
487		487
488	add esi, 0x1000	488	add esi, 0x1000
489	cmp esi, edi	489	cmp esi, edi
490	jb @B	490	jb @B
491		491
492	jmp .update_size	492	jmp .update_size
493	;//-	493	;//-
494	.exit_pop:	494	.exit_pop:
495	.out_of_memory:	495	.out_of_memory:
496	;//-	496	;//-
497	pop edi	497	pop edi
498	pop esi	498	pop esi
499	.exit:	499	.exit:
500	xor eax, eax	500	xor eax, eax

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-A/trunk/core/memory.inc @ 1599 – Rev 1687 → 1689