Subversion Repositories Kolibri OS

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;                                                              ;;

;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;

;; Distributed under terms of the GNU General Public License    ;;

;;                                                              ;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

$Revision: 819 $

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

	   ;mov esi, new_process_loading

	   ;call sys_msg_board_str       ; write message to message board

	   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

	   stdcall map_page,[tmp_task_pdir],eax,dword PG_SW

	   mov edi, [tmp_task_pdir]

	   mov ecx, (OS_BASE shr 20)/4

	   xor eax, eax

	   cld

	   rep stosd

	   mov ecx, (OS_BASE shr 20)/4

	   mov esi, sys_pgdir+(OS_BASE shr 20)

	   rep movsd

	   mov eax, [dir_addr]

	   or eax, PG_SW

	   mov [edi-4096+(page_tabs shr 20)], eax

	   and eax, -4096

	   call set_cr3

	   mov edx, [app_tabs]

	   mov edi, new_app_base

@@:

	   call alloc_page

	   test eax, eax

	   jz .fail

	   stdcall map_page_table, edi, eax

	   add edi, 0x00400000

	   dec edx

	   jnz @B

	   mov edi, new_app_base

	   shr edi, 10

	   add edi, page_tabs

	   mov ecx, [app_tabs]

	   shl ecx, 10

	   xor eax, eax

	   rep stosd

	   mov ecx, [img_pages]

	   mov ebx, PG_UW

	   mov edx, new_app_base

	   mov esi, [img_base]

	   mov edi, new_app_base

	   shr esi, 10

	   shr edi, 10

	   add esi, page_tabs

	   add 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:

	   stdcall map_page,[tmp_task_pdir],dword 0,dword PG_UNMAP

	   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, not 0xFFF

	   stdcall map_page,[tmp_task_pdir],eax,dword PG_SW

	   mov esi, [tmp_task_pdir]

	   mov edi, (OS_BASE shr 20)/4

.destroy:

	   mov eax, [esi]

	   test eax, 1

	   jz .next

	   and eax, not 0xFFF

	   stdcall map_page,[tmp_task_ptab],eax,dword PG_SW

	   stdcall destroy_page_table, [tmp_task_ptab]

	   mov eax, [esi]

	   call free_page

.next:

	   add esi, 4

	   dec edi

	   jnz .destroy

	   mov eax, [pg_dir]

	   call free_page

.exit:

	   stdcall map_page,[tmp_task_ptab],dword 0,dword PG_UNMAP

	   stdcall map_page,[tmp_task_pdir],dword 0,dword PG_UNMAP

	   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 kernel_alloc, RING0_STACK_SIZE+512

	   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

	   push ebx

	   stdcall kernel_alloc, 0x1000

	   pop ebx

	   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 eax, new_app_base

	   mov dword [CURRENT_TASK+ebx+0x10],eax

.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