WebSVN – Kolibri OS – Diff – /kernel/branches/kolibri_pe/core/taskman.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 840 $
 
 
GREEDY_KERNEL  equ 0
 
struc APP_HEADER_00
{ .banner      dq ?
  .version     dd ?    ;+8
  .start       dd ?    ;+12
  .i_end       dd ?    ;+16
  .mem_size    dd ?    ;+20
  .i_param     dd ?    ;+24
}
 
struc APP_HEADER_01
{ .banner      dq ?
  .version     dd ?    ;+8
  .start       dd ?    ;+12
  .i_end       dd ?    ;+16
  .mem_size    dd ?    ;+20
  .stack_top   dd ?    ;+24
  .i_param     dd ?    ;+28
  .i_icon      dd ?    ;+32
}
 
 
struc APP_PARAMS
{ .app_cmdline	 ;0x00
  .app_path	 ;0x04
  .app_eip	 ;0x08
  .app_esp	 ;0x0C
  .app_mem	 ;0x10
}
 
macro _clear_ op
{  mov ecx, op/4
   xor eax, eax
   cld
   rep stosd
}
 
fs_execute_from_sysdir:
	xor	ebx, ebx
	xor	edx, edx
	mov	esi, sysdir_path
 
align 4
proc fs_execute
 
;fn_read:dword, file_size:dword, cluster:dword
 
; ebx - cmdline
; edx - flags
; ebp - full filename
; [esp+4] = procedure DoRead, [esp+8] = filesize & [esp+12]... - arguments for it
 
	   locals
	     cmdline	   rd 64	;256/4
	     filename	   rd 256	;1024/4
	     flags	   dd ?
 
	     save_cr3	   dd ?
	     slot	   dd ?
	     slot_base	   dd ?
	     file_base	   dd ?
	     file_size	   dd ?
					  ;app header data
	     hdr_cmdline   dd ? ;0x00
	     hdr_path	   dd ? ;0x04
	     hdr_eip	   dd ? ;0x08
	     hdr_esp	   dd ? ;0x0C
	     hdr_mem	   dd ? ;0x10
	     hdr_i_end	   dd ? ;0x14
	   endl
 
	   pushad
 
	   mov [flags], edx
 
; [ebp]  pointer to filename
 
	   lea edi, [filename]
	   lea ecx, [edi+1024]
	   mov al, '/'
	   stosb
@@:
	   cmp edi, ecx
	   jae .bigfilename
	   lodsb
	   stosb
	   test al, al
	   jnz @b
	   mov esi, [ebp]
	   test esi, esi
	   jz .namecopied
	   mov byte [edi-1], '/'
@@:
	   cmp edi, ecx
	   jae .bigfilename
	   lodsb
	   stosb
	   test al, al
	   jnz @b
	   jmp .namecopied
.bigfilename:
	   popad
	   mov eax, -ERROR_FILE_NOT_FOUND
	   ret
.namecopied:
 
	   mov [cmdline], ebx
	   test ebx, ebx
	   jz @F
 
	   lea eax, [cmdline]
	   mov dword [eax+252], 0
	   stdcall strncpy, eax, ebx, 255
@@:
	   lea eax, [filename]
	   stdcall load_file, eax
	   mov	ecx, -ERROR_FILE_NOT_FOUND
	   test eax, eax
	   jz .err_file
 
	   mov [file_base], eax
	   mov [file_size], ebx
 
	   lea ebx, [hdr_cmdline]
	   call test_app_header
	   mov ecx, -0x1F
	   test eax, eax
	   jz .err_hdr
 
	   DEBUGF 1,"%s",new_process_loading
 
.wait_lock:
	   cmp [application_table_status],0
	   je .get_lock
	   call   change_task
	   jmp .wait_lock
 
.get_lock:
	   mov eax, 1
	   xchg eax, [application_table_status]
	   cmp eax, 0
	   jne .wait_lock
 
	   call set_application_table_status
 
	   call get_new_process_place
	   test eax, eax
	   mov ecx, -0x20      ; too many processes
	   jz .err
 
	   mov [slot], eax
	   shl eax, 8
	   add eax, SLOT_BASE
	   mov [slot_base], eax
	   mov edi, eax
	   _clear_ 256	   ;clean extended information about process
 
; write application name
	   lea eax, [filename]
	   stdcall strrchr,  eax, '/'  ; now eax points to name without path
 
	   lea esi, [eax+1]
	   test eax, eax
	   jnz @F
	   lea esi, [filename]
@@:
	   mov ecx, 8  ; 8 chars for name
	   mov edi, [slot_base]
.copy_process_name_loop:
	   lodsb
	   cmp al, '.'
	   jz .copy_process_name_done
	   test al, al
	   jz .copy_process_name_done
	   stosb
	   loop .copy_process_name_loop
.copy_process_name_done:
 
 
	   mov ebx, cr3
	   mov [save_cr3], ebx
 
	   stdcall create_app_space,[hdr_mem],[file_base],[file_size]
	   mov ecx, -30  ; no memory
	   test eax, eax
	   jz .failed
 
	   mov	 ebx,[slot_base]
	   mov	 [ebx+APPDATA.dir_table],eax
	   mov	 eax,[hdr_mem]
	   mov	 [ebx+APPDATA.mem_size],eax
 
if GREEDY_KERNEL
else
	   mov ecx, [hdr_mem]
	   mov edi, [file_size]
	   add edi, 4095
	   and edi, not 4095
	   sub ecx, edi
	   jna @F
 
	   xor eax, eax
           cld
	   rep stosb
@@:
end if
 
; release only virtual space, not phisical memory
 
	   stdcall free_kernel_space, [file_base]
	   lea eax, [hdr_cmdline]
	   lea ebx, [cmdline]
	   lea ecx, [filename]
	   stdcall set_app_params ,[slot],eax,ebx,ecx,[flags]
 
	   mov eax, [save_cr3]
	   call set_cr3
 
	   xor ebx, ebx
	   mov [application_table_status],ebx ;unlock application_table_status mutex
	   mov eax,[process_number]  ;set result
	   ret
.failed:
	   mov eax, [save_cr3]
	   call set_cr3
.err:
.err_hdr:
	   stdcall kernel_free,[file_base]
.err_file:
	   xor eax, eax
	   mov [application_table_status],eax
	   mov eax, ecx
	   ret
endp
 
align 4
test_app_header:
	   virtual at eax
	     APP_HEADER_00 APP_HEADER_00
	   end virtual
	   virtual at eax
	     APP_HEADER_01 APP_HEADER_01
	   end virtual
 
	   cmp dword [eax], 'MENU'
	   jne .fail
	   cmp word [eax+4],'ET'
	   jne .fail
 
	   cmp [eax+6], word '00'
	   jne	.check_01_header
 
	   mov	ecx,[APP_HEADER_00.start]
	   mov	[ebx+0x08], ecx 	       ;app_eip
	   mov	edx,[APP_HEADER_00.mem_size]
	   mov	[ebx+0x10], edx 	       ;app_mem
	   shr	edx,1
	   sub	edx,0x10
	   mov	[ebx+0x0C], edx 	       ;app_esp
	   mov	ecx,[APP_HEADER_00.i_param]
	   mov	[ebx], ecx		       ;app_cmdline
	   mov	[ebx+4], dword 0	       ;app_path
	   mov	edx, [APP_HEADER_00.i_end]
	   mov	[ebx+0x14], edx
	   ret
 
 .check_01_header:
 
	   cmp	[eax+6],word '01'
	   jne	.fail
 
	   mov	ecx,[APP_HEADER_01.start]
	   mov	[ebx+0x08], ecx 	       ;app_eip
	   mov	edx,[APP_HEADER_01.mem_size]
 
; \begin{diamond}[20.08.2006]
; sanity check (functions 19,58 load app_i_end bytes and that must
; fit in allocated memory to prevent kernel faults)
	   cmp	edx,[APP_HEADER_01.i_end]
	   jb	.fail
; \end{diamond}[20.08.2006]
 
	   mov	[ebx+0x10], edx 	       ;app_mem
	   mov	ecx,[APP_HEADER_01.stack_top]
	   mov	[ebx+0x0C], ecx 	       ;app_esp
	   mov	edx,[APP_HEADER_01.i_param]
	   mov	[ebx], edx		       ;app_cmdline
	   mov	ecx,[APP_HEADER_01.i_icon]
	   mov	[ebx+4], ecx		       ;app_path
	   mov	edx, [APP_HEADER_01.i_end]
	   mov	[ebx+0x14], edx
	   ret
.fail:
	   xor eax, eax
	   ret
 
align 4
proc get_new_process_place
;input:
;  none
;result:
;  eax=[new_process_place]<>0 - ok
;      0 - failed.
;This function find least empty slot.
;It doesn't increase [TASK_COUNT]!
	   mov	  eax,CURRENT_TASK
	   mov	  ebx,[TASK_COUNT]
	   inc	  ebx
	   shl	  ebx,5
	   add	  ebx,eax		;ebx - address of process information for (last+1) slot
.newprocessplace:
;eax = address of process information for current slot
	   cmp	  eax,ebx
	   jz	  .endnewprocessplace	;empty slot after high boundary
	   add	  eax,0x20
	   cmp	  word [eax+0xa],9	;check process state, 9 means that process slot is empty
	   jnz	  .newprocessplace
.endnewprocessplace:
	   mov	  ebx,eax
	   sub	  eax,CURRENT_TASK
	   shr	  eax,5 		;calculate slot index
	   cmp	  eax,256
	   jge	  .failed		;it should be <256
	   mov	  word [ebx+0xa],9	;set process state to 9 (for slot after hight boundary)
	   ret
.failed:
	   xor	  eax,eax
	   ret
endp
 
align 4
proc create_app_space stdcall, app_size:dword,img_base:dword,img_size:dword
	   locals
	     app_pages	 dd ?
	     img_pages	 dd ?
	     dir_addr	 dd ?
	     app_tabs	 dd ?
	   endl
 
	   mov ebx, pg_data.pg_mutex
	   call wait_mutex   ;ebx
 
	   xor eax, eax
	   mov [dir_addr], eax
 
	   mov eax, [app_size]
	   add eax, 4095
	   and eax, NOT(4095)
	   mov [app_size], eax
	   mov ebx, eax
	   shr eax, 12
	   mov [app_pages], eax
 
	   add ebx, 0x3FFFFF
	   and ebx, NOT(0x3FFFFF)
	   shr ebx, 22
	   mov [app_tabs], ebx
 
	   mov ecx, [img_size]
	   add ecx, 4095
	   and ecx, NOT(4095)
 
	   mov [img_size], ecx
	   shr ecx, 12
	   mov [img_pages], ecx
 
     if GREEDY_KERNEL
	   lea eax, [ecx+ebx+2]    ;only image size
     else
	   lea eax, [eax+ebx+2]    ;all requested memory
     end if
	   cmp eax, [pg_data.pages_free]
	   ja .fail
 
	   call alloc_page
	   test eax, eax
	   jz .fail
	   mov [dir_addr], eax
 
           lea edi, [eax + OS_BASE]
           mov ecx, (OS_BASE shr 20)/4
	   xor eax, eax
	   cld
	   rep stosd
 
           mov ecx, 1024-(OS_BASE shr 20)/4
	   mov esi, sys_pgdir+(OS_BASE shr 20)
	   rep movsd
 
           mov edi, [dir_addr]
           lea eax, [edi+PG_SW]
           mov [edi+OS_BASE+(page_tabs shr 20)], eax
 
           and eax, -4096
	   call set_cr3
 
	   mov edx, [app_tabs]
           xor edi, edi
@@:
	   call alloc_page
	   test eax, eax
	   jz .fail
 
	   stdcall map_page_table, edi, eax
	   add edi, 0x00400000
	   dec edx
	   jnz @B
 
           mov edi, page_tabs
 
	   mov ecx, [app_tabs]
	   shl ecx, 10
	   xor eax, eax
	   rep stosd
 
	   mov ecx, [img_pages]
	   mov ebx, PG_UW
           mov esi, [img_base]
	   shr esi, 10
	   add esi, page_tabs
           xor edx, edx
           mov edi, page_tabs
.remap:
	   lodsd
	   or eax, ebx	    ; force user level r/w access
	   stosd
	   add edx, 0x1000
	   dec [app_pages]
	   dec ecx
	   jnz .remap
 
	   mov ecx, [app_pages]
	   test ecx, ecx
	   jz .done
 
if GREEDY_KERNEL
	   mov eax, 0x02
           rep stosd
else
 
.alloc:
	   call alloc_page
	   test eax, eax
	   jz .fail
 
	   stdcall map_page,edx,eax,dword PG_UW
	   add edx, 0x1000
	   dec [app_pages]
	   jnz .alloc
end if
 
.done:
           dec [pg_data.pg_mutex]
	   mov eax, [dir_addr]
	   ret
.fail:
	   dec [pg_data.pg_mutex]
	   cmp [dir_addr], 0
	   je @f
	   stdcall destroy_app_space, [dir_addr]
@@:
	   xor eax, eax
	   ret
endp
 
align 4
set_cr3:
 
	   mov ebx, [current_slot]
	   mov [ebx+APPDATA.dir_table], eax
	   mov cr3, eax
	   ret
 
align 4
proc destroy_page_table stdcall, pg_tab:dword
 
	   push esi
 
	   mov esi, [pg_tab]
	   mov ecx, 1024
.free:
	   mov eax, [esi]
	   test eax, 1
	   jz .next
           test eax, 1 shl 9
           jnz .next                      ;skip shared pages
	   call free_page
.next:
	   add esi, 4
	   dec ecx
	   jnz .free
	   pop esi
	   ret
endp
 
align 4
proc destroy_app_space stdcall, pg_dir:dword
 
	   mov ebx, pg_data.pg_mutex
	   call wait_mutex   ;ebx
 
	   xor	 edx,edx
	   mov	 eax,0x2
	   mov ebx, [pg_dir]
.loop:
;eax = current slot of process
	   mov	 ecx,eax
	   shl	 ecx,5
	   cmp	 byte [CURRENT_TASK+ecx+0xa],9	;if process running?
	   jz	 @f				 ;skip empty slots
	   shl	 ecx,3
	   cmp	 [SLOT_BASE+ecx+0xB8],ebx	;compare page directory addresses
	   jnz	 @f
	   inc	 edx				;thread found
@@:
	   inc	 eax
	   cmp	 eax,[TASK_COUNT]		;exit loop if we look through all processes
	   jle	 .loop
 
;edx = number of threads
;our process is zombi so it isn't counted
	   cmp	 edx,1
	   jg	 .exit
;if there isn't threads then clear memory.
 
	   mov eax, [pg_dir]
           and eax, -4096
           add eax, OS_BASE
           mov [tmp_task_pdir], eax
           mov esi, eax
           mov edi, (HEAP_BASE shr 20)/4
.destroy:
	   mov eax, [esi]
	   test eax, 1
	   jz .next
	   and eax, not 0xFFF
           add eax, OS_BASE
 
           stdcall destroy_page_table, eax
 
           mov eax, [esi]
	   call free_page
.next:
	   add esi, 4
	   dec edi
	   jnz .destroy
 
	   mov eax, [pg_dir]
	   call free_page
.exit:
	   dec [pg_data.pg_mutex]
	   ret
endp
 
align 4
get_pid:
	   mov eax, [TASK_BASE]
           mov eax, [eax+TASKDATA.pid]
	   ret
 
pid_to_slot:
;Input:
;  eax - pid of process
;Output:
;  eax - slot of process or 0 if process don't exists
;Search process by PID.
    push   ebx
    push   ecx
    mov    ebx,[TASK_COUNT]
    shl    ebx,5
    mov    ecx,2*32
 
.loop:
;ecx=offset of current process info entry
;ebx=maximum permitted offset
    cmp    byte [CURRENT_TASK+ecx+0xa],9
    jz	   .endloop		 ;skip empty slots
    cmp    [CURRENT_TASK+ecx+0x4],eax ;check PID
    jz	   .pid_found
.endloop:
    add    ecx,32
    cmp    ecx,ebx
    jle    .loop
 
    pop    ecx
    pop    ebx
    xor    eax,eax
    ret
 
.pid_found:
    shr    ecx,5
    mov    eax,ecx		 ;convert offset to index of slot
    pop    ecx
    pop    ebx
    ret
 
check_region:
;input:
;  ebx - start of buffer
;  ecx - size of buffer
;result:
;  eax = 1 region lays in app memory
;  eax = 0 region don't lays in app memory
     mov  eax,[CURRENT_TASK]
     jmp  check_process_region
;-----------------------------------------------------------------------------
check_process_region:
;input:
;  eax - slot
;  ebx - start of buffer
;  ecx - size of buffer
;result:
;  eax = 1 region lays in app memory
;  eax = 0 region don't lays in app memory
 
     test ecx,ecx
     jle  .ok
     shl  eax,5
     cmp  word [CURRENT_TASK+eax+0xa],0
     jnz  .failed
     shl  eax,3
     mov  eax,[SLOT_BASE+eax+0xb8]
     test eax,eax
     jz   .failed
 
     mov  eax,1
     ret
 
 
;    call MEM_Get_Linear_Address
;    push ebx
;    push ecx
;    push edx
;    mov  edx,ebx
;    and  edx,not (4096-1)
;    sub  ebx,edx
;    add  ecx,ebx
;    mov  ebx,edx
;    add  ecx,(4096-1)
;    and  ecx,not (4096-1)
;.loop:
;;eax - linear address of page directory
;;ebx - current page
;;ecx - current size
;    mov  edx,ebx
;    shr  edx,22
;    mov  edx,[eax+4*edx]
;    and  edx,not (4096-1)
;    test edx,edx
;    jz   .failed1
;    push eax
;    mov  eax,edx
;    call MEM_Get_Linear_Address
;    mov  edx,ebx
;    shr  edx,12
;    and  edx,(1024-1)
;    mov  eax,[eax+4*edx]
;    and  eax,not (4096-1)
;    test eax,eax
;    pop  eax
;    jz   .failed1
;    add  ebx,4096
;    sub  ecx,4096
;    jg   .loop
;    pop  edx
;    pop  ecx
;    pop  ebx
.ok:
    mov  eax,1
    ret
;
;.failed1:
;    pop  edx
;    pop  ecx
;    pop  ebx
.failed:
    xor  eax,eax
    ret
 
align 4
proc read_process_memory
;Input:
;  eax - process slot
;  ebx - buffer address
;  ecx - buffer size
;  edx - start address in other process
;Output:
;  eax - number of bytes read.
	   locals
	     slot	dd ?
	     buff	dd ?
	     r_count	dd ?
	     offset	dd ?
	     tmp_r_cnt	dd ?
	   endl
 
	   mov [slot], eax
	   mov [buff], ebx
	   and [r_count], 0
	   mov [tmp_r_cnt], ecx
	   mov [offset], edx
 
	   pushad
.read_mem:
	   mov edx, [offset]
	   mov ebx, [tmp_r_cnt]
 
	   mov ecx, 0x400000
	   and edx, 0x3FFFFF
	   sub ecx, edx
	   cmp ecx, ebx
	   jbe @f
	   mov ecx, ebx
@@:
	   cmp ecx, 0x8000
	   jna @F
	   mov ecx, 0x8000
@@:
	   mov eax, [slot]
	   shl	eax,8
	   mov ebx, [offset]
     ;      add ebx, new_app_base
	   push ecx
	   stdcall map_memEx, [proc_mem_map],\
			      [SLOT_BASE+eax+0xB8],\
			      ebx, ecx
	   pop ecx
 
	   mov esi, [offset]
	   and esi, 0xfff
	   add esi, [proc_mem_map]
	   mov edi, [buff]
	   mov edx, ecx
	   rep movsb
	   add [r_count], edx
 
	   add [offset], edx
	   sub [tmp_r_cnt], edx
	   jnz .read_mem
 
	   popad
	   mov eax, [r_count]
	   ret
endp
 
align 4
proc write_process_memory
;Input:
;  eax - process slot
;  ebx - buffer address
;  ecx - buffer size
;  edx - start address in other process
;Output:
;  eax - number of bytes written
 
	   locals
	     slot	dd ?
	     buff	dd ?
	     w_count	dd ?
	     offset	dd ?
	     tmp_w_cnt	dd ?
	   endl
 
	   mov [slot], eax
	   mov [buff], ebx
	   and [w_count], 0
	   mov [tmp_w_cnt], ecx
	   mov [offset], edx
 
	   pushad
.read_mem:
	   mov edx, [offset]
	   mov ebx, [tmp_w_cnt]
 
	   mov ecx, 0x400000
	   and edx, 0x3FFFFF
	   sub ecx, edx
	   cmp ecx, ebx
	   jbe @f
	   mov ecx, ebx
@@:
	   cmp ecx, 0x8000
	   jna @F
	   mov ecx, 0x8000
@@:
	   mov eax, [slot]
	   shl	eax,8
	   mov ebx, [offset]
      ;     add ebx, new_app_base
	   push ecx
	   stdcall map_memEx, [proc_mem_map],\
			      [SLOT_BASE+eax+0xB8],\
			      ebx, ecx
	   pop ecx
 
	   mov edi, [offset]
	   and edi, 0xfff
	   add edi, [proc_mem_map]
	   mov esi, [buff]
	   mov edx, ecx
	   rep movsb
 
	   add [w_count], edx
	   add [offset], edx
	   sub [tmp_w_cnt], edx
	   jnz .read_mem
 
	   popad
	   mov eax, [w_count]
	   ret
endp
 
align 4
proc new_sys_threads
	   locals
	     slot	   dd ?
	     app_cmdline   dd ? ;0x00
	     app_path	   dd ? ;0x04
	     app_eip	   dd ? ;0x08
	     app_esp	   dd ? ;0x0C
	     app_mem	   dd ? ;0x10
	   endl
 
	   cmp eax,1
	   jne .failed			;other subfunctions
 
	   xor	eax,eax
	   mov [app_cmdline], eax
	   mov [app_path], eax
	   mov [app_eip], ebx
	   mov [app_esp], ecx
 
	   ;mov    esi,new_process_loading
	   ;call   sys_msg_board_str
	   DEBUGF 1,"%s",new_process_loading
.wait_lock:
	   cmp [application_table_status],0
	   je .get_lock
	   call   change_task
	   jmp .wait_lock
 
.get_lock:
	   mov eax, 1
	   xchg eax, [application_table_status]
	   cmp eax, 0
	   jne .wait_lock
 
	   call   set_application_table_status
 
	   call get_new_process_place
	   test eax, eax
	   jz .failed
 
	   mov [slot], eax
 
	   mov	  esi,[current_slot]
	   mov	  ebx,esi	      ;ebx=esi - pointer to extended information about current thread
 
	   mov	  edi, eax
	   shl	  edi,8
	   add	  edi,SLOT_BASE
	   mov	  edx,edi	      ;edx=edi - pointer to extended infomation about new thread
	   mov	  ecx,256/4
	   xor eax, eax
	   cld
	   rep	  stosd 	      ;clean extended information about new thread
	   mov	  esi,ebx
	   mov	  edi,edx
	   mov	  ecx,11
	   rep	  movsb 	      ;copy process name
 
	   mov eax,[ebx+APPDATA.heap_base]
	   mov [edx+APPDATA.heap_base], eax
 
	   mov ecx,[ebx+APPDATA.heap_top]
	   mov [edx+APPDATA.heap_top], ecx
 
	   mov eax,[ebx+APPDATA.mem_size]
	   mov [edx+APPDATA.mem_size], eax
 
	   mov ecx,[ebx+APPDATA.dir_table]
	   mov [edx+APPDATA.dir_table],ecx	;copy page directory
 
	   lea eax, [app_cmdline]
	   stdcall set_app_params ,[slot],eax,dword 0,\
					 dword 0,dword 0
 
	   ;mov    esi,new_process_running
	   ;call   sys_msg_board_str     ;output information about succefull startup
	   DEBUGF 1,"%s",new_process_running
 
	   mov	  [application_table_status],0 ;unlock application_table_status mutex
	   mov	  eax,[process_number]	;set result
	   ret
.failed:
	   mov	  [application_table_status],0
	   mov	  eax,-1
	   ret
endp
 
; param
;  ebx=mutex
 
align 4
wait_mutex:
	   push eax
	   push ebx
.do_wait:
	   cmp dword [ebx],0
	   je .get_lock
	   call change_task
	   jmp .do_wait
.get_lock:
	   mov eax, 1
	   xchg eax, [ebx]
	   test eax, eax
	   jnz .do_wait
	   pop ebx
	   pop eax
	   ret
 
EFL_IF	    equ 0x0200
EFL_IOPL1   equ 0x1000
EFL_IOPL2   equ 0x2000
EFL_IOPL3   equ 0x3000
 
 
align 4
proc set_app_params stdcall,slot:dword, params:dword,\
			cmd_line:dword, app_path:dword, flags:dword
 
	   locals
	     pl0_stack dd ?
	   endl
 
           stdcall alloc_pages, (RING0_STACK_SIZE+512) shr 12
           add eax, OS_BASE
	   mov [pl0_stack], eax
 
	   lea edi, [eax+RING0_STACK_SIZE]
 
	   mov eax, [slot]
	   mov ebx, eax
 
	   shl eax, 8
	   mov [eax+SLOT_BASE+APPDATA.fpu_state], edi
	   mov [eax+SLOT_BASE+APPDATA.fpu_handler], 0
	   mov [eax+SLOT_BASE+APPDATA.sse_handler], 0
 
;set default io permission map
	   mov [eax+SLOT_BASE+APPDATA.io_map],\
		  (tss._io_map_0-OS_BASE+PG_MAP)
	   mov [eax+SLOT_BASE+APPDATA.io_map+4],\
		  (tss._io_map_1-OS_BASE+PG_MAP)
 
	   mov esi, fpu_data
	   mov ecx, 512/4
	   rep movsd
 
	   cmp	  ebx,[TASK_COUNT]
	   jle	  .noinc
	   inc	  dword [TASK_COUNT]	   ;update number of processes
.noinc:
	   shl ebx,8
	   lea edx, [ebx+SLOT_BASE+APP_EV_OFFSET]
	   mov [SLOT_BASE+APPDATA.fd_ev+ebx],edx
	   mov [SLOT_BASE+APPDATA.bk_ev+ebx],edx
 
	   add edx, APP_OBJ_OFFSET-APP_EV_OFFSET
	   mov [SLOT_BASE+APPDATA.fd_obj+ebx],edx
	   mov [SLOT_BASE+APPDATA.bk_obj+ebx],edx
 
	   mov ecx, [def_cursor]
	   mov [SLOT_BASE+APPDATA.cursor+ebx],ecx
	   mov eax, [pl0_stack]
	   mov [SLOT_BASE+APPDATA.pl0_stack+ebx],eax
	   add eax, RING0_STACK_SIZE
	   mov [SLOT_BASE+APPDATA.saved_esp0+ebx], eax
 
           call alloc_page
           add eax, OS_BASE
	   mov esi,[current_slot]
	   mov esi,[esi+APPDATA.cur_dir]
	   mov ecx,0x1000/4
	   mov edi,eax
	   mov [ebx+SLOT_BASE+APPDATA.cur_dir],eax
	   rep movsd
 
	   shr ebx,3
 
           mov dword [CURRENT_TASK+ebx+0x10], 0
 
.add_command_line:
	   mov edx,[params]
	   mov edx,[edx]	   ;app_cmdline
	   test edx,edx
	   jz @f		   ;application doesn't need parameters
 
	   mov	   eax, edx
	   add	   eax, 256
	   jc	   @f
 
	   cmp	   eax, [SLOT_BASE+APPDATA.mem_size+ebx*8]
	   ja	   @f
 
	   mov	   byte [edx], 0   ;force empty string if no cmdline given
	   mov	   eax, [cmd_line]
	   test    eax, eax
	   jz	   @f
	   stdcall strncpy, edx, eax, 256
@@:
	   mov edx,[params]
	   mov edx, [edx+4]	   ;app_path
	   test edx,edx
	   jz @F		   ;application don't need path of file
	   mov	   eax, edx
	   add	   eax, 1024
	   jc	   @f
	   cmp	   eax, [SLOT_BASE+APPDATA.mem_size+ebx*8]
	   ja	   @f
	   stdcall strncpy, edx, [app_path], 1024
@@:
	   mov	  ebx,[slot]
	   mov	  eax,ebx
	   shl	  ebx,5
	   lea	  ecx,[draw_data+ebx]  ;ecx - pointer to draw data
 
; set window state to 'normal' (non-minimized/maximized/rolled-up) state
	   mov	   [ebx+window_data+WDATA.fl_wstate], WSTATE_NORMAL
	   mov	   [ebx+window_data+WDATA.fl_redraw], 1
	   add	  ebx,CURRENT_TASK	      ;ebx - pointer to information about process
	   mov	  [ebx+TASKDATA.wnd_number],al;set window number on screen = process slot
 
	   mov	  [ebx+TASKDATA.event_mask],dword 1+2+4 ;set default event flags (see 40 function)
 
	   inc	  dword [process_number]
	   mov	  eax,[process_number]
	   mov	  [ebx+4],eax		;set PID
 
;set draw data to full screen
 
	   mov	  [ecx+0],dword 0
	   mov	  [ecx+4],dword 0
	   mov	  eax,[Screen_Max_X]
	   mov	  [ecx+8],eax
	   mov	  eax,[Screen_Max_Y]
	   mov	  [ecx+12],eax
 
	   mov ebx, [pl0_stack]
	   mov esi,[params]
	   lea ecx, [ebx+REG_EIP]
	   xor eax, eax
 
	   mov [ebx+REG_RET], dword irq0.return
	   mov [ebx+REG_EDI], eax
	   mov [ebx+REG_ESI], eax
	   mov [ebx+REG_EBP], eax
	   mov [ebx+REG_ESP], ecx   ;ebx+REG_EIP
	   mov [ebx+REG_EBX], eax
	   mov [ebx+REG_EDX], eax
	   mov [ebx+REG_ECX], eax
	   mov [ebx+REG_EAX], eax
 
	   mov eax, [esi+0x08]	     ;app_eip
	   mov [ebx+REG_EIP],  eax   ;app_entry
	   mov [ebx+REG_CS], dword app_code
	   mov [ebx+REG_EFLAGS], dword EFL_IOPL1+EFL_IF
 
	   mov eax, [esi+0x0C]	     ;app_esp
	   mov [ebx+REG_APP_ESP], eax	 ;app_stack
	   mov [ebx+REG_SS], dword app_data
 
	   lea ecx, [ebx+REG_RET]
	   mov ebx, [slot]
	   shl ebx, 5
	   mov [ebx*8+SLOT_BASE+APPDATA.saved_esp], ecx
 
	   xor	ecx, ecx	; process state - running
; set if debuggee
	   test byte [flags], 1
	   jz	.no_debug
	   inc	ecx		; process state - suspended
	   mov	eax,[CURRENT_TASK]
	   mov	[SLOT_BASE+ebx*8+APPDATA.debugger_slot],eax
.no_debug:
	   mov	[CURRENT_TASK+ebx+TASKDATA.state], cl
	   ;mov    esi,new_process_running
	   ;call   sys_msg_board_str     ;output information about succefull startup
	   DEBUGF 1,"%s",new_process_running
	   ret
endp
 
include "debug.inc"
>

Rev 839	Rev 840
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2007. 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: 839 $	8	$Revision: 840 $
9		9
10		10
11	GREEDY_KERNEL equ 0	11	GREEDY_KERNEL equ 0
12		12
13	struc APP_HEADER_00	13	struc APP_HEADER_00
14	{ .banner dq ?	14	{ .banner dq ?
15	.version dd ? ;+8	15	.version dd ? ;+8
16	.start dd ? ;+12	16	.start dd ? ;+12
17	.i_end dd ? ;+16	17	.i_end dd ? ;+16
18	.mem_size dd ? ;+20	18	.mem_size dd ? ;+20
19	.i_param dd ? ;+24	19	.i_param dd ? ;+24
20	}	20	}
21		21
22	struc APP_HEADER_01	22	struc APP_HEADER_01
23	{ .banner dq ?	23	{ .banner dq ?
24	.version dd ? ;+8	24	.version dd ? ;+8
25	.start dd ? ;+12	25	.start dd ? ;+12
26	.i_end dd ? ;+16	26	.i_end dd ? ;+16
27	.mem_size dd ? ;+20	27	.mem_size dd ? ;+20
28	.stack_top dd ? ;+24	28	.stack_top dd ? ;+24
29	.i_param dd ? ;+28	29	.i_param dd ? ;+28
30	.i_icon dd ? ;+32	30	.i_icon dd ? ;+32
31	}	31	}
32		32
33		33
34	struc APP_PARAMS	34	struc APP_PARAMS
35	{ .app_cmdline ;0x00	35	{ .app_cmdline ;0x00
36	.app_path ;0x04	36	.app_path ;0x04
37	.app_eip ;0x08	37	.app_eip ;0x08
38	.app_esp ;0x0C	38	.app_esp ;0x0C
39	.app_mem ;0x10	39	.app_mem ;0x10
40	}	40	}
41		41
42	macro _clear_ op	42	macro _clear_ op
43	{ mov ecx, op/4	43	{ mov ecx, op/4
44	xor eax, eax	44	xor eax, eax
45	cld	45	cld
46	rep stosd	46	rep stosd
47	}	47	}
48		48
49	fs_execute_from_sysdir:	49	fs_execute_from_sysdir:
50	xor ebx, ebx	50	xor ebx, ebx
51	xor edx, edx	51	xor edx, edx
52	mov esi, sysdir_path	52	mov esi, sysdir_path
53		53
54	align 4	54	align 4
55	proc fs_execute	55	proc fs_execute
56		56
57	;fn_read:dword, file_size:dword, cluster:dword	57	;fn_read:dword, file_size:dword, cluster:dword
58		58
59	; ebx - cmdline	59	; ebx - cmdline
60	; edx - flags	60	; edx - flags
61	; ebp - full filename	61	; ebp - full filename
62	; [esp+4] = procedure DoRead, [esp+8] = filesize & [esp+12]... - arguments for it	62	; [esp+4] = procedure DoRead, [esp+8] = filesize & [esp+12]... - arguments for it
63		63
64	locals	64	locals
65	cmdline rd 64 ;256/4	65	cmdline rd 64 ;256/4
66	filename rd 256 ;1024/4	66	filename rd 256 ;1024/4
67	flags dd ?	67	flags dd ?
68		68
69	save_cr3 dd ?	69	save_cr3 dd ?
70	slot dd ?	70	slot dd ?
71	slot_base dd ?	71	slot_base dd ?
72	file_base dd ?	72	file_base dd ?
73	file_size dd ?	73	file_size dd ?
74	;app header data	74	;app header data
75	hdr_cmdline dd ? ;0x00	75	hdr_cmdline dd ? ;0x00
76	hdr_path dd ? ;0x04	76	hdr_path dd ? ;0x04
77	hdr_eip dd ? ;0x08	77	hdr_eip dd ? ;0x08
78	hdr_esp dd ? ;0x0C	78	hdr_esp dd ? ;0x0C
79	hdr_mem dd ? ;0x10	79	hdr_mem dd ? ;0x10
80	hdr_i_end dd ? ;0x14	80	hdr_i_end dd ? ;0x14
81	endl	81	endl
82		82
83	pushad	83	pushad
84		84
85	mov [flags], edx	85	mov [flags], edx
86		86
87	; [ebp] pointer to filename	87	; [ebp] pointer to filename
88		88
89	lea edi, [filename]	89	lea edi, [filename]
90	lea ecx, [edi+1024]	90	lea ecx, [edi+1024]
91	mov al, '/'	91	mov al, '/'
92	stosb	92	stosb
93	@@:	93	@@:
94	cmp edi, ecx	94	cmp edi, ecx
95	jae .bigfilename	95	jae .bigfilename
96	lodsb	96	lodsb
97	stosb	97	stosb
98	test al, al	98	test al, al
99	jnz @b	99	jnz @b
100	mov esi, [ebp]	100	mov esi, [ebp]
101	test esi, esi	101	test esi, esi
102	jz .namecopied	102	jz .namecopied
103	mov byte [edi-1], '/'	103	mov byte [edi-1], '/'
104	@@:	104	@@:
105	cmp edi, ecx	105	cmp edi, ecx
106	jae .bigfilename	106	jae .bigfilename
107	lodsb	107	lodsb
108	stosb	108	stosb
109	test al, al	109	test al, al
110	jnz @b	110	jnz @b
111	jmp .namecopied	111	jmp .namecopied
112	.bigfilename:	112	.bigfilename:
113	popad	113	popad
114	mov eax, -ERROR_FILE_NOT_FOUND	114	mov eax, -ERROR_FILE_NOT_FOUND
115	ret	115	ret
116	.namecopied:	116	.namecopied:
117		117
118	mov [cmdline], ebx	118	mov [cmdline], ebx
119	test ebx, ebx	119	test ebx, ebx
120	jz @F	120	jz @F
121		121
122	lea eax, [cmdline]	122	lea eax, [cmdline]
123	mov dword [eax+252], 0	123	mov dword [eax+252], 0
124	stdcall strncpy, eax, ebx, 255	124	stdcall strncpy, eax, ebx, 255
125	@@:	125	@@:
126	lea eax, [filename]	126	lea eax, [filename]
127	stdcall load_file, eax	127	stdcall load_file, eax
128	mov ecx, -ERROR_FILE_NOT_FOUND	128	mov ecx, -ERROR_FILE_NOT_FOUND
129	test eax, eax	129	test eax, eax
130	jz .err_file	130	jz .err_file
131		131
132	mov [file_base], eax	132	mov [file_base], eax
133	mov [file_size], ebx	133	mov [file_size], ebx
134		134
135	lea ebx, [hdr_cmdline]	135	lea ebx, [hdr_cmdline]
136	call test_app_header	136	call test_app_header
137	mov ecx, -0x1F	137	mov ecx, -0x1F
138	test eax, eax	138	test eax, eax
139	jz .err_hdr	139	jz .err_hdr
140		140
141	DEBUGF 1,"%s",new_process_loading	141	DEBUGF 1,"%s",new_process_loading
142		142
143	.wait_lock:	143	.wait_lock:
144	cmp [application_table_status],0	144	cmp [application_table_status],0
145	je .get_lock	145	je .get_lock
146	call change_task	146	call change_task
147	jmp .wait_lock	147	jmp .wait_lock
148		148
149	.get_lock:	149	.get_lock:
150	mov eax, 1	150	mov eax, 1
151	xchg eax, [application_table_status]	151	xchg eax, [application_table_status]
152	cmp eax, 0	152	cmp eax, 0
153	jne .wait_lock	153	jne .wait_lock
154		154
155	call set_application_table_status	155	call set_application_table_status
156		156
157	call get_new_process_place	157	call get_new_process_place
158	test eax, eax	158	test eax, eax
159	mov ecx, -0x20 ; too many processes	159	mov ecx, -0x20 ; too many processes
160	jz .err	160	jz .err
161		161
162	mov [slot], eax	162	mov [slot], eax
163	shl eax, 8	163	shl eax, 8
164	add eax, SLOT_BASE	164	add eax, SLOT_BASE
165	mov [slot_base], eax	165	mov [slot_base], eax
166	mov edi, eax	166	mov edi, eax
167	_clear_ 256 ;clean extended information about process	167	_clear_ 256 ;clean extended information about process
168		168
169	; write application name	169	; write application name
170	lea eax, [filename]	170	lea eax, [filename]
171	stdcall strrchr, eax, '/' ; now eax points to name without path	171	stdcall strrchr, eax, '/' ; now eax points to name without path
172		172
173	lea esi, [eax+1]	173	lea esi, [eax+1]
174	test eax, eax	174	test eax, eax
175	jnz @F	175	jnz @F
176	lea esi, [filename]	176	lea esi, [filename]
177	@@:	177	@@:
178	mov ecx, 8 ; 8 chars for name	178	mov ecx, 8 ; 8 chars for name
179	mov edi, [slot_base]	179	mov edi, [slot_base]
180	.copy_process_name_loop:	180	.copy_process_name_loop:
181	lodsb	181	lodsb
182	cmp al, '.'	182	cmp al, '.'
183	jz .copy_process_name_done	183	jz .copy_process_name_done
184	test al, al	184	test al, al
185	jz .copy_process_name_done	185	jz .copy_process_name_done
186	stosb	186	stosb
187	loop .copy_process_name_loop	187	loop .copy_process_name_loop
188	.copy_process_name_done:	188	.copy_process_name_done:
189		189
190		190
191	mov ebx, cr3	191	mov ebx, cr3
192	mov [save_cr3], ebx	192	mov [save_cr3], ebx
193		193
194	stdcall create_app_space,[hdr_mem],[file_base],[file_size]	194	stdcall create_app_space,[hdr_mem],[file_base],[file_size]
195	mov ecx, -30 ; no memory	195	mov ecx, -30 ; no memory
196	test eax, eax	196	test eax, eax
197	jz .failed	197	jz .failed
198		198
199	mov ebx,[slot_base]	199	mov ebx,[slot_base]
200	mov [ebx+APPDATA.dir_table],eax	200	mov [ebx+APPDATA.dir_table],eax
201	mov eax,[hdr_mem]	201	mov eax,[hdr_mem]
202	mov [ebx+APPDATA.mem_size],eax	202	mov [ebx+APPDATA.mem_size],eax
203		203
204	if GREEDY_KERNEL	204	if GREEDY_KERNEL
205	else	205	else
206	mov ecx, [hdr_mem]	206	mov ecx, [hdr_mem]
207	mov edi, [file_size]	207	mov edi, [file_size]
208	add edi, 4095	208	add edi, 4095
209	and edi, not 4095	209	and edi, not 4095
210	sub ecx, edi	210	sub ecx, edi
211	jna @F	211	jna @F
212		212
213	xor eax, eax	213	xor eax, eax
214	cld	214	cld
215	rep stosb	215	rep stosb
216	@@:	216	@@:
217	end if	217	end if
218		218
219	; release only virtual space, not phisical memory	219	; release only virtual space, not phisical memory
220		220
221	stdcall free_kernel_space, [file_base]	221	stdcall free_kernel_space, [file_base]
222	lea eax, [hdr_cmdline]	222	lea eax, [hdr_cmdline]
223	lea ebx, [cmdline]	223	lea ebx, [cmdline]
224	lea ecx, [filename]	224	lea ecx, [filename]
225	stdcall set_app_params ,[slot],eax,ebx,ecx,[flags]	225	stdcall set_app_params ,[slot],eax,ebx,ecx,[flags]
226		226
227	mov eax, [save_cr3]	227	mov eax, [save_cr3]
228	call set_cr3	228	call set_cr3
229		229
230	xor ebx, ebx	230	xor ebx, ebx
231	mov [application_table_status],ebx ;unlock application_table_status mutex	231	mov [application_table_status],ebx ;unlock application_table_status mutex
232	mov eax,[process_number] ;set result	232	mov eax,[process_number] ;set result
233	ret	233	ret
234	.failed:	234	.failed:
235	mov eax, [save_cr3]	235	mov eax, [save_cr3]
236	call set_cr3	236	call set_cr3
237	.err:	237	.err:
238	.err_hdr:	238	.err_hdr:
239	stdcall kernel_free,[file_base]	239	stdcall kernel_free,[file_base]
240	.err_file:	240	.err_file:
241	xor eax, eax	241	xor eax, eax
242	mov [application_table_status],eax	242	mov [application_table_status],eax
243	mov eax, ecx	243	mov eax, ecx
244	ret	244	ret
245	endp	245	endp
246		246
247	align 4	247	align 4
248	test_app_header:	248	test_app_header:
249	virtual at eax	249	virtual at eax
250	APP_HEADER_00 APP_HEADER_00	250	APP_HEADER_00 APP_HEADER_00
251	end virtual	251	end virtual
252	virtual at eax	252	virtual at eax
253	APP_HEADER_01 APP_HEADER_01	253	APP_HEADER_01 APP_HEADER_01
254	end virtual	254	end virtual
255		255
256	cmp dword [eax], 'MENU'	256	cmp dword [eax], 'MENU'
257	jne .fail	257	jne .fail
258	cmp word [eax+4],'ET'	258	cmp word [eax+4],'ET'
259	jne .fail	259	jne .fail
260		260
261	cmp [eax+6], word '00'	261	cmp [eax+6], word '00'
262	jne .check_01_header	262	jne .check_01_header
263		263
264	mov ecx,[APP_HEADER_00.start]	264	mov ecx,[APP_HEADER_00.start]
265	mov [ebx+0x08], ecx ;app_eip	265	mov [ebx+0x08], ecx ;app_eip
266	mov edx,[APP_HEADER_00.mem_size]	266	mov edx,[APP_HEADER_00.mem_size]
267	mov [ebx+0x10], edx ;app_mem	267	mov [ebx+0x10], edx ;app_mem
268	shr edx,1	268	shr edx,1
269	sub edx,0x10	269	sub edx,0x10
270	mov [ebx+0x0C], edx ;app_esp	270	mov [ebx+0x0C], edx ;app_esp
271	mov ecx,[APP_HEADER_00.i_param]	271	mov ecx,[APP_HEADER_00.i_param]
272	mov [ebx], ecx ;app_cmdline	272	mov [ebx], ecx ;app_cmdline
273	mov [ebx+4], dword 0 ;app_path	273	mov [ebx+4], dword 0 ;app_path
274	mov edx, [APP_HEADER_00.i_end]	274	mov edx, [APP_HEADER_00.i_end]
275	mov [ebx+0x14], edx	275	mov [ebx+0x14], edx
276	ret	276	ret
277		277
278	.check_01_header:	278	.check_01_header:
279		279
280	cmp [eax+6],word '01'	280	cmp [eax+6],word '01'
281	jne .fail	281	jne .fail
282		282
283	mov ecx,[APP_HEADER_01.start]	283	mov ecx,[APP_HEADER_01.start]
284	mov [ebx+0x08], ecx ;app_eip	284	mov [ebx+0x08], ecx ;app_eip
285	mov edx,[APP_HEADER_01.mem_size]	285	mov edx,[APP_HEADER_01.mem_size]
286		286
287	; \begin{diamond}[20.08.2006]	287	; \begin{diamond}[20.08.2006]
288	; sanity check (functions 19,58 load app_i_end bytes and that must	288	; sanity check (functions 19,58 load app_i_end bytes and that must
289	; fit in allocated memory to prevent kernel faults)	289	; fit in allocated memory to prevent kernel faults)
290	cmp edx,[APP_HEADER_01.i_end]	290	cmp edx,[APP_HEADER_01.i_end]
291	jb .fail	291	jb .fail
292	; \end{diamond}[20.08.2006]	292	; \end{diamond}[20.08.2006]
293		293
294	mov [ebx+0x10], edx ;app_mem	294	mov [ebx+0x10], edx ;app_mem
295	mov ecx,[APP_HEADER_01.stack_top]	295	mov ecx,[APP_HEADER_01.stack_top]
296	mov [ebx+0x0C], ecx ;app_esp	296	mov [ebx+0x0C], ecx ;app_esp
297	mov edx,[APP_HEADER_01.i_param]	297	mov edx,[APP_HEADER_01.i_param]
298	mov [ebx], edx ;app_cmdline	298	mov [ebx], edx ;app_cmdline
299	mov ecx,[APP_HEADER_01.i_icon]	299	mov ecx,[APP_HEADER_01.i_icon]
300	mov [ebx+4], ecx ;app_path	300	mov [ebx+4], ecx ;app_path
301	mov edx, [APP_HEADER_01.i_end]	301	mov edx, [APP_HEADER_01.i_end]
302	mov [ebx+0x14], edx	302	mov [ebx+0x14], edx
303	ret	303	ret
304	.fail:	304	.fail:
305	xor eax, eax	305	xor eax, eax
306	ret	306	ret
307		307
308	align 4	308	align 4
309	proc get_new_process_place	309	proc get_new_process_place
310	;input:	310	;input:
311	; none	311	; none
312	;result:	312	;result:
313	; eax=[new_process_place]<>0 - ok	313	; eax=[new_process_place]<>0 - ok
314	; 0 - failed.	314	; 0 - failed.
315	;This function find least empty slot.	315	;This function find least empty slot.
316	;It doesn't increase [TASK_COUNT]!	316	;It doesn't increase [TASK_COUNT]!
317	mov eax,CURRENT_TASK	317	mov eax,CURRENT_TASK
318	mov ebx,[TASK_COUNT]	318	mov ebx,[TASK_COUNT]
319	inc ebx	319	inc ebx
320	shl ebx,5	320	shl ebx,5
321	add ebx,eax ;ebx - address of process information for (last+1) slot	321	add ebx,eax ;ebx - address of process information for (last+1) slot
322	.newprocessplace:	322	.newprocessplace:
323	;eax = address of process information for current slot	323	;eax = address of process information for current slot
324	cmp eax,ebx	324	cmp eax,ebx
325	jz .endnewprocessplace ;empty slot after high boundary	325	jz .endnewprocessplace ;empty slot after high boundary
326	add eax,0x20	326	add eax,0x20
327	cmp word [eax+0xa],9 ;check process state, 9 means that process slot is empty	327	cmp word [eax+0xa],9 ;check process state, 9 means that process slot is empty
328	jnz .newprocessplace	328	jnz .newprocessplace
329	.endnewprocessplace:	329	.endnewprocessplace:
330	mov ebx,eax	330	mov ebx,eax
331	sub eax,CURRENT_TASK	331	sub eax,CURRENT_TASK
332	shr eax,5 ;calculate slot index	332	shr eax,5 ;calculate slot index
333	cmp eax,256	333	cmp eax,256
334	jge .failed ;it should be <256	334	jge .failed ;it should be <256
335	mov word [ebx+0xa],9 ;set process state to 9 (for slot after hight boundary)	335	mov word [ebx+0xa],9 ;set process state to 9 (for slot after hight boundary)
336	ret	336	ret
337	.failed:	337	.failed:
338	xor eax,eax	338	xor eax,eax
339	ret	339	ret
340	endp	340	endp
341		341
342	align 4	342	align 4
343	proc create_app_space stdcall, app_size:dword,img_base:dword,img_size:dword	343	proc create_app_space stdcall, app_size:dword,img_base:dword,img_size:dword
344	locals	344	locals
345	app_pages dd ?	345	app_pages dd ?
346	img_pages dd ?	346	img_pages dd ?
347	dir_addr dd ?	347	dir_addr dd ?
348	app_tabs dd ?	348	app_tabs dd ?
349	endl	349	endl
350		350
351	mov ebx, pg_data.pg_mutex	351	mov ebx, pg_data.pg_mutex
352	call wait_mutex ;ebx	352	call wait_mutex ;ebx
353		353
354	xor eax, eax	354	xor eax, eax
355	mov [dir_addr], eax	355	mov [dir_addr], eax
356		356
357	mov eax, [app_size]	357	mov eax, [app_size]
358	add eax, 4095	358	add eax, 4095
359	and eax, NOT(4095)	359	and eax, NOT(4095)
360	mov [app_size], eax	360	mov [app_size], eax
361	mov ebx, eax	361	mov ebx, eax
362	shr eax, 12	362	shr eax, 12
363	mov [app_pages], eax	363	mov [app_pages], eax
364		364
365	add ebx, 0x3FFFFF	365	add ebx, 0x3FFFFF
366	and ebx, NOT(0x3FFFFF)	366	and ebx, NOT(0x3FFFFF)
367	shr ebx, 22	367	shr ebx, 22
368	mov [app_tabs], ebx	368	mov [app_tabs], ebx
369		369
370	mov ecx, [img_size]	370	mov ecx, [img_size]
371	add ecx, 4095	371	add ecx, 4095
372	and ecx, NOT(4095)	372	and ecx, NOT(4095)
373		373
374	mov [img_size], ecx	374	mov [img_size], ecx
375	shr ecx, 12	375	shr ecx, 12
376	mov [img_pages], ecx	376	mov [img_pages], ecx
377		377
378	if GREEDY_KERNEL	378	if GREEDY_KERNEL
379	lea eax, [ecx+ebx+2] ;only image size	379	lea eax, [ecx+ebx+2] ;only image size
380	else	380	else
381	lea eax, [eax+ebx+2] ;all requested memory	381	lea eax, [eax+ebx+2] ;all requested memory
382	end if	382	end if
383	cmp eax, [pg_data.pages_free]	383	cmp eax, [pg_data.pages_free]
384	ja .fail	384	ja .fail
385		385
386	call alloc_page	386	call alloc_page
387	test eax, eax	387	test eax, eax
388	jz .fail	388	jz .fail
389	mov [dir_addr], eax	389	mov [dir_addr], eax
390		390
391	lea edi, [eax + OS_BASE]	391	lea edi, [eax + OS_BASE]
392	mov ecx, (OS_BASE shr 20)/4	392	mov ecx, (OS_BASE shr 20)/4
393	xor eax, eax	393	xor eax, eax
394	cld	394	cld
395	rep stosd	395	rep stosd
396		396
397	mov ecx, 1024-(OS_BASE shr 20)/4	397	mov ecx, 1024-(OS_BASE shr 20)/4
398	mov esi, sys_pgdir+(OS_BASE shr 20)	398	mov esi, sys_pgdir+(OS_BASE shr 20)
399	rep movsd	399	rep movsd
400		400
401	mov edi, [dir_addr]	401	mov edi, [dir_addr]
402	lea eax, [edi+PG_SW]	402	lea eax, [edi+PG_SW]
403	mov [edi+OS_BASE+(page_tabs shr 20)], eax	403	mov [edi+OS_BASE+(page_tabs shr 20)], eax
404		404
405	and eax, -4096	405	and eax, -4096
406	call set_cr3	406	call set_cr3
407		407
408	mov edx, [app_tabs]	408	mov edx, [app_tabs]
409	xor edi, edi	409	xor edi, edi
410	@@:	410	@@:
411	call alloc_page	411	call alloc_page
412	test eax, eax	412	test eax, eax
413	jz .fail	413	jz .fail
414		414
415	stdcall map_page_table, edi, eax	415	stdcall map_page_table, edi, eax
416	add edi, 0x00400000	416	add edi, 0x00400000
417	dec edx	417	dec edx
418	jnz @B	418	jnz @B
419		419
420	mov edi, page_tabs	420	mov edi, page_tabs
421		421
422	mov ecx, [app_tabs]	422	mov ecx, [app_tabs]
423	shl ecx, 10	423	shl ecx, 10
424	xor eax, eax	424	xor eax, eax
425	rep stosd	425	rep stosd
426		426
427	mov ecx, [img_pages]	427	mov ecx, [img_pages]
428	mov ebx, PG_UW	428	mov ebx, PG_UW
429	mov esi, [img_base]	429	mov esi, [img_base]
430	shr esi, 10	430	shr esi, 10
431	add esi, page_tabs	431	add esi, page_tabs
432	xor edx, edx	432	xor edx, edx
433	mov edi, page_tabs	433	mov edi, page_tabs
434	.remap:	434	.remap:
435	lodsd	435	lodsd
436	or eax, ebx ; force user level r/w access	436	or eax, ebx ; force user level r/w access
437	stosd	437	stosd
438	add edx, 0x1000	438	add edx, 0x1000
439	dec [app_pages]	439	dec [app_pages]
440	dec ecx	440	dec ecx
441	jnz .remap	441	jnz .remap
442		442
443	mov ecx, [app_pages]	443	mov ecx, [app_pages]
444	test ecx, ecx	444	test ecx, ecx
445	jz .done	445	jz .done
446		446
447	if GREEDY_KERNEL	447	if GREEDY_KERNEL
448	mov eax, 0x02	448	mov eax, 0x02
449	rep stosd	449	rep stosd
450	else	450	else
451		451
452	.alloc:	452	.alloc:
453	call alloc_page	453	call alloc_page
454	test eax, eax	454	test eax, eax
455	jz .fail	455	jz .fail
456		456
457	stdcall map_page,edx,eax,dword PG_UW	457	stdcall map_page,edx,eax,dword PG_UW
458	add edx, 0x1000	458	add edx, 0x1000
459	dec [app_pages]	459	dec [app_pages]
460	jnz .alloc	460	jnz .alloc
461	end if	461	end if
462		462
463	.done:	463	.done:
464	dec [pg_data.pg_mutex]	464	dec [pg_data.pg_mutex]
465	mov eax, [dir_addr]	465	mov eax, [dir_addr]
466	ret	466	ret
467	.fail:	467	.fail:
468	dec [pg_data.pg_mutex]	468	dec [pg_data.pg_mutex]
469	cmp [dir_addr], 0	469	cmp [dir_addr], 0
470	je @f	470	je @f
471	stdcall destroy_app_space, [dir_addr]	471	stdcall destroy_app_space, [dir_addr]
472	@@:	472	@@:
473	xor eax, eax	473	xor eax, eax
474	ret	474	ret
475	endp	475	endp
476		476
477	align 4	477	align 4
478	set_cr3:	478	set_cr3:
479		479
480	mov ebx, [current_slot]	480	mov ebx, [current_slot]
481	mov [ebx+APPDATA.dir_table], eax	481	mov [ebx+APPDATA.dir_table], eax
482	mov cr3, eax	482	mov cr3, eax
483	ret	483	ret
484		484
485	align 4	485	align 4
486	proc destroy_page_table stdcall, pg_tab:dword	486	proc destroy_page_table stdcall, pg_tab:dword
487		487
488	push esi	488	push esi
489		489
490	mov esi, [pg_tab]	490	mov esi, [pg_tab]
491	mov ecx, 1024	491	mov ecx, 1024
492	.free:	492	.free:
493	mov eax, [esi]	493	mov eax, [esi]
494	test eax, 1	494	test eax, 1
495	jz .next	495	jz .next
496	test eax, 1 shl 9	496	test eax, 1 shl 9
497	jnz .next ;skip shared pages	497	jnz .next ;skip shared pages
498	call free_page	498	call free_page
499	.next:	499	.next:
500	add esi, 4	500	add esi, 4

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri_pe/core/taskman.inc @ 839 – Rev 839 → 840