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
}
align 4
proc test_app_header stdcall, header:dword
virtual at ebx
APP_HEADER_00 APP_HEADER_00
end virtual
mov ebx, [header]
cmp [ebx+6], word '00'
jne .check_01_header
mov eax,[APP_HEADER_00.start]
mov [app_start],eax
mov eax,[APP_HEADER_00.i_end]
mov [app_i_end],eax
mov eax,[APP_HEADER_00.mem_size]
mov [app_mem],eax
shr eax,1
sub eax,0x10
mov [app_esp],eax
mov eax,[APP_HEADER_00.i_param]
mov [app_i_param],eax
mov [app_i_icon],dword 0
mov eax,1
ret
.check_01_header:
virtual at ebx
APP_HEADER_01 APP_HEADER_01
end virtual
cmp [ebx+6],word '01'
jne .no_01_header
mov eax,[APP_HEADER_01.start]
mov [app_start],eax
mov eax,[APP_HEADER_01.i_end]
mov [app_i_end],eax
mov eax,[APP_HEADER_01.mem_size]
mov [app_mem],eax
mov eax,[APP_HEADER_01.stack_top]
mov [app_esp],eax
mov eax,[APP_HEADER_01.i_param]
mov [app_i_param],eax
mov eax,[APP_HEADER_01.i_icon]
mov [app_i_icon],eax
mov eax,1
ret
.no_01_header:
xor eax, eax
ret
endp
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)
; mov [new_process_place], eax
ret
.failed:
xor eax,eax
ret
endp
align 4
proc create_app_space stdcall, app_size:dword,img_size:dword
locals
app_pages dd ?
img_pages dd ?
dir_addr dd ?
app_tabs dd ?
endl
stdcall wait_mutex, pg_data.pg_mutex
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 esi, sys_pgdir
mov edi, [tmp_task_pdir]
mov ecx, 384
cld
rep movsd
mov ecx, 384
xor eax, eax
cld
rep stosd
mov ecx, 256
mov esi, sys_pgdir+0xc00
rep movsd
mov eax, [dir_addr]
or eax, PG_SW
mov ebx, [tmp_task_pdir]
mov [ebx+0x600], eax
mov eax, [dir_addr]
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, pages_tab
mov ecx, [app_tabs]
shl ecx, 10
xor eax, eax
rep stosd
mov edx, new_app_base
.alloc:
call alloc_page
test eax, eax
jz .fail
stdcall map_page,edx,eax,dword PG_UW
add edx, 0x1000
sub [app_pages], 1
sub [img_pages], 1
jnz .alloc
mov ecx, [app_pages]
and ecx, ecx
jz .next
mov ebx, edx
shr edx, 12
.reserve:
mov dword [pages_tab+edx*4], 0x02
invlpg [ebx]
inc edx
dec ecx
jnz .reserve
.next:
mov edi, new_app_base
mov ecx, [img_size]
shr ecx, 2
xor eax, eax
cld
rep stosd
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
jz @f
stdcall destroy_app_space, [dir_addr]
@@:
xor eax, eax
ret
endp
align 4
set_cr3:
mov esi, [CURRENT_TASK]
mov ebx, esi
shl esi,8
mov [PROC_BASE+esi+0xB8],eax
imul ebx,tss_step
add ebx,tss_data
mov [ebx+28], 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
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
stdcall wait_mutex, pg_data.pg_mutex
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 [PROC_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]
add esi, 0x604
mov edi, 383
.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
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 dd ?
flags dd ?
filename dd ?
retval dd ?
endl
pushad
mov [cmdline], ebx
mov [flags], edx
mov eax, [ebp]
mov [filename], eax
stdcall wait_mutex, pg_data.tmp_task_mutex
mov edi, [tmp_task_data]
mov ecx, (2048+256)/4
xor eax, eax
rep stosd
mov esi, [filename]
mov edi, [tmp_task_data]
add edi, TMP_FILE_NAME
mov ecx, 1024
rep movsb
mov esi, [filename]
mov edi, [tmp_task_data]
add edi, TMP_ICON_OFFS
mov ecx, 1024
rep movsb
mov esi, [cmdline]
test esi, esi
jz @f
mov edi, [tmp_task_data]
add edi, TMP_CMD_LINE
mov ecx, 256
rep movsb
@@:
mov eax, TMP_FILE_NAME
add eax, [tmp_task_data]
mov ebx, [tmp_task_data] ;cmd line
add ebx, TMP_CMD_LINE
stdcall fs_exec, eax, ebx, [flags], [ebp+8],\
[ebp+12], [ebp+16],[ebp+20]
mov [retval], eax
popad
mov [pg_data.tmp_task_mutex], 0
mov eax, [retval]
ret
endp
align 4
proc fs_exec stdcall file_name:dword, cmd_line:dword, flags:dword,\
fn_read:dword, file_size:dword,\
cluster:dword, some_data:dword
locals
slot dd ?
app_path_size dd ?
save_cr3 dd ?
img_size dd ?
endl
; check filename length - with terminating NULL must be no more than 1024 symbols
mov edi, [file_name]
mov ecx, 1024
xor eax, eax
repnz scasb
jz @f
mov eax, -ERROR_FILE_NOT_FOUND
ret
@@:
sub edi, [file_name]
mov [app_path_size], edi
mov esi, new_process_loading
call sys_msg_board_str ; write message to message board
pushfd
cli
.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
mov edi,eax
shl edi,8
add edi,PROC_BASE
mov ecx,256/4
xor eax,eax
cld
rep stosd ;clean extended information about process
; write application name
mov edi, [file_name]
mov ecx, [app_path_size]
add edi, ecx
dec edi
std
mov al, '/'
repnz scasb
cld
jnz @f
inc edi
@@:
inc edi
; now edi points to name without path
mov esi, edi
mov ecx, 8 ; 8 chars for name
mov edi, [slot]
shl edi, cl
add edi, PROC_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 al, ' '
rep stosb
pop eax
mov cl, 3 ; 3 chars for extension
dec esi
@@:
dec eax
cmp eax, esi
jbe .copy_process_ext_done
cmp byte [eax], '.'
jnz @b
lea esi, [eax+1]
.copy_process_ext_loop:
lodsb
test al, al
jz .copy_process_ext_done
stosb
loop .copy_process_ext_loop
.copy_process_ext_done:
mov al, ' '
rep stosb
; read header
lea eax, [file_size]
mov ebx, [eax]
mov [img_size], ebx
mov edi, TMP_BUFF
call [fn_read]
test eax, eax
jnz .err
; check menuet signature
mov ecx, -0x1F
;check MENUET signature
cmp [TMP_BUFF],dword 'MENU'
jnz .err
cmp [TMP_BUFF+4],word 'ET'
jnz .err
stdcall test_app_header, TMP_BUFF
test eax, eax
jz .err
mov eax, cr3
mov [save_cr3], eax
if GREEDY_KERNEL
stdcall create_app_space,[app_mem],[img_size]
else
stdcall create_app_space,[app_mem],[app_mem]
end if
test eax, eax
jz .failed
mov ebx,[slot]
shl ebx,8
mov [PROC_BASE+ebx+0xB8],eax
mov esi, TMP_BUFF
mov edi, new_app_base
mov ecx, 512/4
cld
rep movsd
;read file
@@:
lea eax, [file_size]
cmp dword [eax], 0
jz .done
push edi
call [fn_read]
pop edi
add edi, 512
test eax, eax
jz @b
cmp ebx, 6
jne .failed
.done:
stdcall add_app_parameters, [slot], new_app_base,\
[cmd_line],[file_name],[flags]
mov eax, [save_cr3]
call set_cr3
xor eax, eax
mov [application_table_status],eax ;unlock application_table_status mutex
popfd
mov eax,[process_number] ;set result
ret
.failed:
mov eax, [save_cr3]
call set_cr3
.err:
popfd
xor eax, eax
mov [application_table_status],eax
ret
endp
align 4
proc add_app_parameters stdcall,slot:dword,img_base:dword,\
cmd_line:dword, app_path:dword, flags:dword
mov edi, [slot]
mov esi, [fpu_data]
bt [cpu_caps], CAPS_SSE
jnc .no_SSE
shl edi, 8
mov eax, edi
lea edi, [esi+edi*2]
mov [eax+PROC_BASE+APPDATA.fpu_state], edi
mov [eax+PROC_BASE+APPDATA.fpu_handler], 0
mov [eax+PROC_BASE+APPDATA.sse_handler], 0
mov ecx, 512/4
jmp @F
.no_SSE:
mov eax, edi
shl eax, 8
mov ebx, edi
shl edi, 7
shl ebx, 4
sub edi, ebx ;edi*=112
add edi, esi
mov [eax+PROC_BASE+APPDATA.fpu_state], edi
mov [eax+PROC_BASE+APPDATA.fpu_handler], 0
mov [eax+PROC_BASE+APPDATA.sse_handler], 0
mov ecx, 112/4
@@:
rep movsd
mov ebx,[slot]
cmp ebx,[TASK_COUNT]
jle .noinc
inc dword [TASK_COUNT] ;update number of processes
.noinc:
shl ebx,8
mov eax,[app_mem]
mov [PROC_BASE+APPDATA.mem_size+ebx],eax
mov ecx, [def_cursor]
mov [PROC_BASE+APPDATA.cursor+ebx],ecx
shr ebx,3
mov eax, new_app_base
mov dword [CURRENT_TASK+ebx+0x10],eax
.add_command_line:
mov edx,[app_i_param]
test edx,edx
jz .no_command_line ;application don't need parameters
mov eax,[cmd_line]
test eax,eax
jz .no_command_line ;no parameters specified
;calculate parameter length
xor ecx,ecx
.command_line_len:
cmp byte [eax],0
jz .command_line_len_end
inc eax
inc ecx
cmp ecx,255
jl .command_line_len
.command_line_len_end:
;ecx - parameter length
;edx - address of parameters in new process address space
inc ecx
mov edi, [img_base]
add edi, edx
mov esi, [cmd_line]
rep movsb
.no_command_line:
mov edx,[app_i_icon]
test edx,edx
jz .no_command_line_1 ;application don't need path of file
mov esi,[app_path]
test esi, esi
jz .no_command_line_1 ;application don't need path of file
mov ecx, 64
mov edi, [img_base]
add edi, edx
rep movsb
.no_command_line_1:
mov ebx,[slot]
mov eax,ebx
shl ebx,5
; 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
mov ecx,ebx
add ecx,(draw_data-CURRENT_TASK) ;ecx - pointer to draw data
;set draw data to full screen
mov [ecx+0],dword 0
mov [ecx+4],dword 0
mov eax,[SCR_X_SIZE]
mov [ecx+8],eax
mov eax,[SCR_Y_SIZE]
mov [ecx+12],eax
;set cr3 register in TSS of application
mov ecx,[slot]
shl ecx,8
mov eax,[PROC_BASE+0xB8+ecx]
;or eax, PG_NOCACHE
mov [l.cr3],eax
mov eax,[app_start]
mov [l.eip],eax ;set eip in TSS
mov eax,[app_esp]
mov [l.esp],eax ;set stack in TSS
;gdt
mov ax,app_code ;ax - selector of code segment
mov [l.cs],ax
mov ax,app_data
mov [l.ss],ax
mov [l.ds],ax
mov [l.es],ax
mov [l.fs],ax
mov ax,graph_data ;ax - selector of graphic segment
mov [l.gs],ax
mov [l.io],word 128
mov [l.eflags],dword 0x1202
mov [l.ss0],os_data
mov ebx,[slot]
shl ebx,12
add ebx,sysint_stack_data+4096
mov [l.esp0],ebx
;copy tss to it place
mov eax,tss_sceleton
mov ebx,[slot]
imul ebx,tss_step
add ebx,tss_data ;ebx - address of application TSS
mov ecx,120
call memmove
;Add IO access table - bit array of permitted ports
or eax,-1
mov edi,[slot]
imul edi,tss_step
add edi,tss_data+128
mov ecx,2048
cld
rep stosd ;full access to 2048*8=16384 ports
mov ecx,ebx ;ecx - address of application TSS
mov edi,[slot]
shl edi,3
;set TSS descriptor
mov [edi+gdts+tss0+0],word tss_step ;limit (size)
mov [edi+gdts+tss0+2],cx ;part of offset
mov eax,ecx
shr eax,16
mov [edi+gdts+tss0+4],al ;part of offset
mov [edi+gdts+tss0+7],ah ;part of offset
mov [edi+gdts+tss0+5],word 01010000b*256+11101001b ;system flags
;flush keyboard and buttons queue
mov [KEY_COUNT],byte 0
mov [BTN_COUNT],byte 0
mov edi,[slot]
shl edi,5
add edi,window_data
mov ebx,[slot]
movzx esi,word [WIN_STACK+ebx*2]
lea esi,[WIN_POS+esi*2]
call windowactivate ;gui initialization
mov ebx,[slot]
shl ebx,5
mov [CURRENT_TASK+ebx+0xa],byte 0 ;set process state - running
; set if debuggee
mov eax, [flags]
test byte [flags], 1
jz .no_debug
mov [CURRENT_TASK+ebx+0xa],byte 1 ;set process state - suspended
mov eax,[CURRENT_TASK]
mov [PROC_BASE+ebx*8+0xac],eax ;set debugger PID - current
.no_debug:
mov esi,new_process_running
call sys_msg_board_str ;output information about succefull startup
ret
endp
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,[PROC_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
mov [r_count], ecx
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],\
[PROC_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 [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
mov [w_count], ecx
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],\
[PROC_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 [offset], edx
sub [tmp_w_cnt], edx
jnz .read_mem
popad
mov eax, [w_count]
ret
endp
align 4
proc new_sys_threads
locals
thread_start dd ?
thread_stack dd ?
params dd ?
slot dd ?
endl
mov [thread_start], ebx
mov [thread_stack], ecx
mov [params], 0
xor edx,edx ; flags=0
cmp eax,1
jnz .failed ;other subfunctions
mov esi,new_process_loading
call sys_msg_board_str
.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
xor eax,eax
mov [app_i_param],eax
mov [app_i_icon],eax
mov ebx, [thread_start]
mov ecx, [thread_stack]
mov [app_start],ebx
mov [app_esp],ecx
mov esi,[CURRENT_TASK]
shl esi,8
add esi,PROC_BASE
mov ebx,esi ;ebx=esi - pointer to extended information about current thread
mov edi,[slot]
shl edi,8
add edi,PROC_BASE
mov edx,edi ;edx=edi - pointer to extended infomation about new thread
mov ecx,256/4
rep stosd ;clean extended information about new thread
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 [app_mem],eax ;set memory size
mov eax,[ebx+0xb8]
mov [edx+0xb8],eax ;copy page directory
stdcall add_app_parameters, [slot], new_app_base,\
[params], dword 0,dword 0
mov esi,new_process_running
call sys_msg_board_str ;output information about succefull startup
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
align 4
proc wait_mutex stdcall, mutex:dword
mov ebx, [mutex]
.wait_lock:
cmp dword [ebx],0
je .get_lock
push ebx
call change_task
pop ebx
jmp .wait_lock
.get_lock:
mov eax, 1
xchg eax, [ebx]
test eax, eax
jnz .wait_lock
ret
endp
include "debug.inc"
iglobal
new_process_loading db 'K : New Process - loading',13,10,0
new_process_running db 'K : New Process - done',13,10,0
start_not_enough_memory db 'K : New Process - not enough memory',13,10,0
endg