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

Rev	Author	Line No.	Line
431	serge	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
		2	;; ;;
		3	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
		4	;; Distributed under terms of the GNU General Public License ;;
		5	;; ;;
		6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
		7
593	mikedld	8	$Revision: 928 $
		9
897	serge	10	EFL_IF equ 0x0200
		11	EFL_IOPL1 equ 0x1000
		12	EFL_IOPL2 equ 0x2000
		13	EFL_IOPL3 equ 0x3000
593	mikedld	14
164	serge	15
		16	struc APP_HEADER_00
		17	{ .banner dq ?
		18	.version dd ? ;+8
		19	.start dd ? ;+12
		20	.i_end dd ? ;+16
		21	.mem_size dd ? ;+20
		22	.i_param dd ? ;+24
		23	}
		24
		25	struc APP_HEADER_01
		26	{ .banner dq ?
		27	.version dd ? ;+8
		28	.start dd ? ;+12
		29	.i_end dd ? ;+16
		30	.mem_size dd ? ;+20
		31	.stack_top dd ? ;+24
		32	.i_param dd ? ;+28
		33	.i_icon dd ? ;+32
		34	}
		35
237	serge	36
		37	struc APP_PARAMS
774	Rus	38	{ .app_cmdline ;0x00
		39	.app_path ;0x04
		40	.app_eip ;0x08
		41	.app_esp ;0x0C
		42	.app_mem ;0x10
237	serge	43	}
		44
		45	macro _clear_ op
		46	{ mov ecx, op/4
		47	xor eax, eax
		48	cld
		49	rep stosd
		50	}
		51
164	serge	52	align 4
897	serge	53	test_app_header:
		54	virtual at eax
		55	APP_HEADER_00 APP_HEADER_00
		56	end virtual
		57	virtual at eax
		58	APP_HEADER_01 APP_HEADER_01
		59	end virtual
363	serge	60
897	serge	61	cmp dword [eax], 'MENU'
		62	jne .fail
		63	cmp word [eax+4],'ET'
		64	jne .fail
363	serge	65
897	serge	66	cmp [eax+6], word '00'
		67	jne .check_01_header
363	serge	68
897	serge	69	mov ecx,[APP_HEADER_00.start]
		70	mov [ebx+0x08], ecx ;app_eip
		71	mov edx,[APP_HEADER_00.mem_size]
		72	mov [ebx+0x10], edx ;app_mem
		73	shr edx,1
		74	sub edx,0x10
		75	mov [ebx+0x0C], edx ;app_esp
		76	mov ecx,[APP_HEADER_00.i_param]
		77	mov [ebx], ecx ;app_cmdline
		78	mov [ebx+4], dword 0 ;app_path
		79	mov edx, [APP_HEADER_00.i_end]
		80	mov [ebx+0x14], edx
		81	ret
		82
		83	.check_01_header:
		84
		85	cmp [eax+6],word '01'
		86	jne .fail
		87
		88	mov ecx,[APP_HEADER_01.start]
		89	mov [ebx+0x08], ecx ;app_eip
		90	mov edx,[APP_HEADER_01.mem_size]
		91
		92	; \begin{diamond}[20.08.2006]
		93	; sanity check (functions 19,58 load app_i_end bytes and that must
		94	; fit in allocated memory to prevent kernel faults)
		95	cmp edx,[APP_HEADER_01.i_end]
		96	jb .fail
		97	; \end{diamond}[20.08.2006]
		98
		99	mov [ebx+0x10], edx ;app_mem
		100	mov ecx,[APP_HEADER_01.stack_top]
		101	mov [ebx+0x0C], ecx ;app_esp
		102	mov edx,[APP_HEADER_01.i_param]
		103	mov [ebx], edx ;app_cmdline
		104	mov ecx,[APP_HEADER_01.i_icon]
		105	mov [ebx+4], ecx ;app_path
		106	mov edx, [APP_HEADER_01.i_end]
		107	mov [ebx+0x14], edx
		108	ret
		109	.fail:
		110	xor eax, eax
		111	ret
		112
908	serge	113	align 4
897	serge	114	proc mnt_exec stdcall file_base:dword, file_size:dword, \
		115	path:dword, cmd_line:dword, flags:dword
		116
886	serge	117	locals
897	serge	118	cmdline rb 256
		119	filename rb 1024
363	serge	120
886	serge	121	save_cr3 dd ?
		122	slot dd ?
		123	slot_base dd ?
897	serge	124
886	serge	125	;app header data
		126	hdr_cmdline dd ? ;0x00
		127	hdr_path dd ? ;0x04
		128	hdr_eip dd ? ;0x08
		129	hdr_esp dd ? ;0x0C
		130	hdr_mem dd ? ;0x10
		131	hdr_i_end dd ? ;0x14
		132	endl
164	serge	133
897	serge	134	push ebx
		135	push edi
		136	push esi
363	serge	137
897	serge	138	mov esi, [path]
886	serge	139	lea edi, [filename]
		140	lea ecx, [edi+1024]
521	diamond	141	@@:
886	serge	142	cmp edi, ecx
		143	jae .bigfilename
		144	lodsb
		145	stosb
		146	test al, al
		147	jnz @b
897	serge	148
914	serge	149	lea edi, [cmdline]
		150	mov dword [edi],0
897	serge	151	mov esi, [cmd_line]
886	serge	152	test esi, esi
897	serge	153	jz .no_cmdline
		154
		155	lea ecx, [edi+255]
		156	mov [edi+252], dword 0
521	diamond	157	@@:
886	serge	158	cmp edi, ecx
897	serge	159	jae .no_cmdline
		160
886	serge	161	lodsb
		162	stosb
		163	test al, al
		164	jnz @b
363	serge	165
897	serge	166	.no_cmdline:
519	serge	167
897	serge	168	mov eax, [file_base]
886	serge	169	lea ebx, [hdr_cmdline]
		170	call test_app_header
		171	mov ecx, -0x1F
		172	test eax, eax
		173	jz .err_hdr
237	serge	174
886	serge	175	DEBUGF 1,"%s",new_process_loading
237	serge	176
897	serge	177	lea ebx, [application_table_status]
		178	call wait_mutex
237	serge	179
886	serge	180	call set_application_table_status
237	serge	181
886	serge	182	call get_new_process_place
		183	test eax, eax
		184	mov ecx, -0x20 ; too many processes
		185	jz .err
237	serge	186
886	serge	187	mov [slot], eax
		188	shl eax, 8
		189	add eax, SLOT_BASE
		190	mov [slot_base], eax
		191	mov edi, eax
		192	_clear_ 256 ;clean extended information about process
237	serge	193
		194	; write application name
886	serge	195	lea eax, [filename]
		196	stdcall strrchr, eax, '/' ; now eax points to name without path
237	serge	197
886	serge	198	lea esi, [eax+1]
		199	test eax, eax
		200	jnz @F
		201	lea esi, [filename]
237	serge	202	@@:
886	serge	203	mov ecx, 8 ; 8 chars for name
		204	mov edi, [slot_base]
237	serge	205	.copy_process_name_loop:
886	serge	206	lodsb
		207	cmp al, '.'
		208	jz .copy_process_name_done
		209	test al, al
		210	jz .copy_process_name_done
		211	stosb
		212	loop .copy_process_name_loop
237	serge	213	.copy_process_name_done:
		214
886	serge	215	mov ebx, cr3
		216	mov [save_cr3], ebx
839	serge	217
843	serge	218	stdcall create_app_space,[hdr_mem],[file_base],[file_size]
		219	mov ecx, -30 ; no memory
886	serge	220	test eax, eax
		221	jz .failed
237	serge	222
886	serge	223	mov ebx,[slot_base]
		224	mov [ebx+APPDATA.dir_table],eax
		225	mov eax,[hdr_mem]
		226	mov [ebx+APPDATA.mem_size],eax
237	serge	227
886	serge	228	mov ecx, [hdr_mem]
		229	mov edi, [file_size]
914	serge	230	; add edi, 4095
		231	; and edi, not 4095
886	serge	232	sub ecx, edi
		233	jna @F
269	serge	234
886	serge	235	xor eax, eax
889	serge	236	cld
886	serge	237	rep stosb
247	serge	238	@@:
888	serge	239	mov ecx, [file_base]
		240	call @mem_free@4
269	serge	241
886	serge	242	lea eax, [hdr_cmdline]
		243	lea ebx, [cmdline]
		244	lea ecx, [filename]
		245	stdcall set_app_params ,[slot],eax,ebx,ecx,[flags]
237	serge	246
886	serge	247	mov eax, [save_cr3]
		248	call set_cr3
237	serge	249
914	serge	250	mov eax,[process_number] ;set result
897	serge	251	mov [application_table_status], 0 ;unlock application_table_status mutex
		252
		253	pop edi
		254	pop esi
		255	pop ebx
		256
886	serge	257	ret
897	serge	258
		259	.bigfilename:
		260	pop edi
		261	pop esi
		262	pop ebx
		263	mov eax, -ERROR_FILE_NOT_FOUND
		264	ret
237	serge	265	.failed:
886	serge	266	mov eax, [save_cr3]
		267	call set_cr3
269	serge	268	.err:
247	serge	269	.err_hdr:
887	serge	270	mov ecx, [file_base]
		271	call @mem_free@4
897	serge	272
		273	pop edi
		274	pop esi
		275	pop ebx
		276
886	serge	277	xor eax, eax
		278	mov [application_table_status],eax
		279	mov eax, ecx
		280	ret
237	serge	281	endp
164	serge	282
237	serge	283	align 4
908	serge	284	proc pe_app_param stdcall path:dword, raw:dword, ex_pg_dir:dword, ex_stack:dword
164	serge	285
897	serge	286	locals
		287	slot dd ?
		288	slot_base dd ?
908	serge	289	pl0_stack dd ?
897	serge	290	endl
164	serge	291
897	serge	292	push ebx
		293	push esi
		294	push edi
164	serge	295
897	serge	296	lea ebx, [application_table_status]
		297	call wait_mutex
164	serge	298
897	serge	299	call set_application_table_status
164	serge	300
897	serge	301	call get_new_process_place
		302	test eax, eax
		303	mov ecx, -0x20 ; too many processes
		304	jz .err
237	serge	305
897	serge	306	mov [slot], eax
		307	shl eax, 8
		308	add eax, SLOT_BASE
		309	mov [slot_base], eax
		310	mov edi, eax
		311	_clear_ 256 ;clean extended information about process
381	serge	312
897	serge	313	; write application name
908	serge	314	stdcall strrchr, [path], '/' ; now eax points to name without path
897	serge	315	lea esi, [eax+1]
		316	test eax, eax
		317	jnz @F
		318	lea esi, [path]
		319	@@:
		320	mov ecx, 8 ; 8 chars for name
		321	mov edi, [slot_base]
		322	.copy_process_name_loop:
		323	lodsb
		324	cmp al, '.'
		325	jz .copy_process_name_done
		326	test al, al
		327	jz .copy_process_name_done
		328	stosb
		329	loop .copy_process_name_loop
		330	.copy_process_name_done:
381	serge	331
897	serge	332	mov eax, [ex_pg_dir]
		333	mov ebx, [slot_base]
		334	mov [ebx+APPDATA.dir_table],eax
		335
		336	;mov eax,[hdr_mem]
		337	;mov [ebx+APPDATA.mem_size],eax
		338
		339
908	serge	340	mov ecx, 1
		341	call @core_alloc@4
		342	lea edi, [eax+OS_BASE]
		343	mov [pl0_stack], edi
		344
897	serge	345	mov [ebx+APPDATA.pl0_stack], edi
		346	add edi, RING0_STACK_SIZE
		347	mov [ebx+APPDATA.saved_esp0], edi
		348	mov [ebx+APPDATA.fpu_state], edi
		349	mov [ebx+APPDATA.fpu_handler], 0
		350	mov [ebx+APPDATA.sse_handler], 0
		351
		352	;set default io permission map
		353	mov [ebx+APPDATA.io_map],\
		354	(tss._io_map_0-OS_BASE+PG_MAP)
		355	mov [ebx+APPDATA.io_map+4],\
		356	(tss._io_map_1-OS_BASE+PG_MAP)
		357
		358	mov esi, fpu_data
		359	mov ecx, 512/4
		360	rep movsd
		361
		362	mov eax, [slot]
		363	cmp eax,[TASK_COUNT]
		364	jle .noinc
		365	inc dword [TASK_COUNT] ;update number of processes
		366	.noinc:
		367	lea edx, [ebx+APP_EV_OFFSET]
		368	mov [ebx+APPDATA.fd_ev],edx
		369	mov [ebx+APPDATA.bk_ev],edx
		370
		371	add edx, APP_OBJ_OFFSET-APP_EV_OFFSET
		372	mov [ebx+APPDATA.fd_obj],edx
		373	mov [ebx+APPDATA.bk_obj],edx
		374
		375	mov ecx, [def_cursor]
		376	mov [ebx+APPDATA.cursor],ecx
		377
		378	xor ecx, ecx
		379	call @core_alloc@4
908	serge	380	lea edi, [eax+OS_BASE] ; FIXME
897	serge	381
		382	mov esi,[current_slot]
		383	mov esi,[esi+APPDATA.cur_dir]
		384	mov ecx,0x1000/4
908	serge	385	mov [ebx+APPDATA.cur_dir],edi
897	serge	386	rep movsd
		387
		388	mov ebx, [slot]
		389	mov eax, ebx
		390	shl ebx, 5
		391	mov dword [CURRENT_TASK+ebx+0x10], 0
		392
		393	lea ecx,[draw_data+ebx] ;ecx - pointer to draw data
		394
		395	; set window state to 'normal' (non-minimized/maximized/rolled-up) state
		396	mov [ebx+window_data+WDATA.fl_wstate], WSTATE_NORMAL
		397	mov [ebx+window_data+WDATA.fl_redraw], 1
		398	add ebx,CURRENT_TASK ;ebx - pointer to information about process
		399	mov [ebx+TASKDATA.wnd_number],al;set window number on screen = process slot
		400
		401	mov [ebx+TASKDATA.event_mask],dword 1+2+4 ;set default event flags (see 40 function)
		402
		403	inc dword [process_number]
		404	mov eax,[process_number]
		405	mov [ebx+4],eax ;set PID
		406
		407	;set draw data to full screen
		408
		409	mov [ecx+0],dword 0
		410	mov [ecx+4],dword 0
		411	mov eax,[Screen_Max_X]
		412	mov [ecx+8],eax
		413	mov eax,[Screen_Max_Y]
		414	mov [ecx+12],eax
		415
908	serge	416	mov ebx, [pl0_stack]
897	serge	417
		418	mov eax, [raw]
908	serge	419	lea ecx, [ebx+REG_EDI]
		420	mov edx, [ex_stack]
897	serge	421
908	serge	422	mov [ebx+REG_ENTRY], dword _sys_app_entry
		423	mov [ebx+REG_RESTART], dword _pe_restart
		424	mov [ebx+REG_RAW], eax
		425	mov [ebx+REG_CSTACK], ecx
		426	mov [ebx+REG_USTACK], edx
		427
		428	lea ebx, [ebx+REG_ENTRY]
		429
897	serge	430	mov ecx, [slot]
		431	shl ecx, 5
		432	mov [ecx*8+SLOT_BASE+APPDATA.saved_esp], ebx
908	serge	433	mov [CURRENT_TASK+ecx+TASKDATA.state], 0
897	serge	434
908	serge	435	DEBUGF 1,"%s",new_process_running
897	serge	436	.err:
914	serge	437	mov eax,[process_number] ;set result
897	serge	438	mov [application_table_status], 0 ;unlock application_table_status mutex
		439
		440	pop edi
		441	pop esi
		442	pop ebx
		443
774	Rus	444	ret
897	serge	445	endp
164	serge	446
908	serge	447	align 4
		448	_pe_restart:
		449	xchg bx, bx
		450	add esp, 12
		451	popad
		452	iretd
897	serge	453
908	serge	454
164	serge	455	align 4
		456	proc get_new_process_place
		457	;input:
		458	; none
		459	;result:
		460	; eax=[new_process_place]<>0 - ok
		461	; 0 - failed.
		462	;This function find least empty slot.
		463	;It doesn't increase [TASK_COUNT]!
774	Rus	464	mov eax,CURRENT_TASK
		465	mov ebx,[TASK_COUNT]
		466	inc ebx
		467	shl ebx,5
		468	add ebx,eax ;ebx - address of process information for (last+1) slot
164	serge	469	.newprocessplace:
		470	;eax = address of process information for current slot
774	Rus	471	cmp eax,ebx
		472	jz .endnewprocessplace ;empty slot after high boundary
		473	add eax,0x20
		474	cmp word [eax+0xa],9 ;check process state, 9 means that process slot is empty
		475	jnz .newprocessplace
164	serge	476	.endnewprocessplace:
774	Rus	477	mov ebx,eax
		478	sub eax,CURRENT_TASK
		479	shr eax,5 ;calculate slot index
		480	cmp eax,256
		481	jge .failed ;it should be <256
		482	mov word [ebx+0xa],9 ;set process state to 9 (for slot after hight boundary)
		483	ret
164	serge	484	.failed:
774	Rus	485	xor eax,eax
		486	ret
164	serge	487	endp
		488
		489	align 4
269	serge	490	proc create_app_space stdcall, app_size:dword,img_base:dword,img_size:dword
886	serge	491	locals
		492	app_pages dd ?
		493	img_pages dd ?
		494	dir_addr dd ?
		495	app_tabs dd ?
		496	endl
164	serge	497
886	serge	498	mov ebx, pg_data.pg_mutex
		499	call wait_mutex ;ebx
164	serge	500
886	serge	501	xor eax, eax
		502	mov [dir_addr], eax
164	serge	503
886	serge	504	mov eax, [app_size]
		505	add eax, 4095
861	serge	506	and eax, not 4095
886	serge	507	mov [app_size], eax
		508	mov ebx, eax
		509	shr eax, 12
		510	mov [app_pages], eax
170	serge	511
886	serge	512	add ebx, 0x3FFFFF
861	serge	513	and ebx, not 0x3FFFFF
886	serge	514	shr ebx, 22
		515	mov [app_tabs], ebx
164	serge	516
886	serge	517	mov ecx, [img_size]
		518	add ecx, 4095
861	serge	519	and ecx, not 4095
164	serge	520
886	serge	521	mov [img_size], ecx
		522	shr ecx, 12
		523	mov [img_pages], ecx
164	serge	524
854	serge	525	call _alloc_page
886	serge	526	test eax, eax
		527	mov [dir_addr], eax
		528	jz .fail
164	serge	529
861	serge	530	;lea edi, [eax + OS_BASE]
		531	;mov ecx, (OS_BASE shr 20)/4
		532	;xor eax, eax
		533	;cld
		534	;rep stosd
465	serge	535
861	serge	536	;mov ecx, 1024-(OS_BASE shr 20)/4
		537	;mov esi, _sys_pdbr+(OS_BASE shr 20)
		538	;rep movsd
164	serge	539
861	serge	540	lea edi, [eax+OS_BASE]
		541	mov ecx, 512
		542	xor eax, eax
		543	cld
		544	rep stosd
		545
		546	mov ecx, 512
		547	mov esi, _sys_pdbr+(HEAP_BASE shr 20)
		548	rep movsd
		549
839	serge	550	mov edi, [dir_addr]
		551	lea eax, [edi+PG_SW]
		552	mov [edi+OS_BASE+(page_tabs shr 20)], eax
378	serge	553
861	serge	554	mov eax, edi
886	serge	555	call set_cr3
164	serge	556
861	serge	557	mov edx, [app_tabs]
		558	mov edi, master_tab
164	serge	559	@@:
854	serge	560	call _alloc_page
886	serge	561	test eax, eax
		562	jz .fail
164	serge	563
861	serge	564	or eax, PG_UW
		565	stosd
		566	dec edx
		567	jnz @B
164	serge	568
839	serge	569	mov edi, page_tabs
886	serge	570	mov ecx, [app_tabs]
		571	shl ecx, 10
		572	xor eax, eax
		573	rep stosd
164	serge	574
886	serge	575	mov ecx, [app_pages]
888	serge	576	xor ebx, ebx
164	serge	577	.alloc:
888	serge	578	xor ecx, ecx
		579	call @core_alloc@4
886	serge	580	test eax, eax
		581	jz .fail
164	serge	582
888	serge	583	stdcall map_page,ebx,eax,dword PG_UW
		584	add ebx, 0x1000
886	serge	585	dec [app_pages]
		586	jnz .alloc
164	serge	587
888	serge	588	mov ecx, [img_size] ; FIXME remap md
		589	mov esi, [img_base]
		590	xor edi, edi
		591
		592	rep movsb
		593
269	serge	594	.done:
839	serge	595	dec [pg_data.pg_mutex]
886	serge	596	mov eax, [dir_addr]
		597	ret
164	serge	598	.fail:
886	serge	599	dec [pg_data.pg_mutex]
		600	cmp [dir_addr], 0
		601	je @f
		602	stdcall destroy_app_space, [dir_addr]
164	serge	603	@@:
886	serge	604	xor eax, eax
		605	ret
164	serge	606	endp
		607
908	serge	608	;addr_t __fastcall pe_app_space(size_t size);
164	serge	609	align 4
908	serge	610	@pe_app_space@4:
		611	sub esp, 16
		612
		613	mov [esp+4], ebx
		614	mov [esp+8], esi
		615	mov [esp+12], edi
		616
		617	lea ebx, [ecx+0x3FFFFF]
		618
		619	xor ecx, ecx
897	serge	620	call @core_alloc@4
		621	test eax, eax
908	serge	622	mov [esp], eax
897	serge	623	jz .fail
		624
		625	mov ecx, 512
		626	lea edi, [eax + OS_BASE]
		627	xor eax, eax
		628	cld
		629	rep stosd
		630
		631	mov ecx, 512
		632	mov esi, _sys_pdbr+(HEAP_BASE shr 20)
		633	rep movsd
		634
908	serge	635	mov esi, [esp]
		636	shr ebx, 22
		637	.new_ptab:
		638	xor ecx, ecx
		639	call @core_alloc@4
		640	test eax, eax
		641	jz .fail
897	serge	642
908	serge	643	lea edi, [eax+OS_BASE]
		644	or eax, PG_UW
		645	mov [esi+OS_BASE], eax
897	serge	646
908	serge	647	mov ecx, 1024
897	serge	648	xor eax, eax
		649	rep stosd
		650
908	serge	651	add esi, 4
		652	dec ebx
		653	jnz .new_ptab
		654
		655	xor ecx, ecx
		656	call @core_alloc@4
		657	test eax, eax
		658	jz .fail
		659
		660	lea edi, [eax+OS_BASE]
		661	or eax, PG_UW
		662
		663	mov ebx, [esp]
		664	lea edx, [ebx+PG_SW]
		665	mov [ebx+OS_BASE+(0x7FC00000 shr 20)], eax
		666	mov [ebx+OS_BASE+(page_tabs shr 20)], edx
		667
		668	mov ecx, 1024
		669	xor eax, eax
		670	rep stosd
		671
		672	mov eax, ebx
897	serge	673	.fail:
908	serge	674	mov ebx, [esp+4]
		675	mov esi, [esp+8]
		676	mov edi, [esp+12]
		677
		678	add esp, 16
897	serge	679	ret
		680
		681	align 4
164	serge	682	set_cr3:
465	serge	683
886	serge	684	mov ebx, [current_slot]
		685	mov [ebx+APPDATA.dir_table], eax
		686	mov cr3, eax
		687	ret
164	serge	688
		689	align 4
		690	proc destroy_page_table stdcall, pg_tab:dword
		691
888	serge	692	push ebx
886	serge	693	push esi
164	serge	694
886	serge	695	mov esi, [pg_tab]
888	serge	696	mov ebx, 1024
164	serge	697	.free:
888	serge	698	mov ecx, [esi]
		699	test ecx, 1
886	serge	700	jz .next
		701
888	serge	702	test ecx, 1 shl 9
819	serge	703	jnz .next ;skip shared pages
886	serge	704
888	serge	705	call @core_free@4
164	serge	706	.next:
886	serge	707	add esi, 4
888	serge	708	dec ebx
886	serge	709	jnz .free
		710	pop esi
888	serge	711	pop ebx
886	serge	712	ret
164	serge	713	endp
		714
		715	align 4
		716	proc destroy_app_space stdcall, pg_dir:dword
		717
886	serge	718	mov ebx, pg_data.pg_mutex
		719	call wait_mutex ;ebx
164	serge	720
886	serge	721	xor edx,edx
		722	mov eax,0x2
		723	mov ebx, [pg_dir]
164	serge	724	.loop:
		725	;eax = current slot of process
886	serge	726	mov ecx,eax
		727	shl ecx,5
		728	cmp byte [CURRENT_TASK+ecx+0xa],9 ;if process running?
		729	jz @f ;skip empty slots
		730
		731	shl ecx,3
		732	cmp [SLOT_BASE+ecx+0xB8],ebx ;compare page directory addresses
		733	jnz @f
		734
		735	inc edx ;thread found
164	serge	736	@@:
886	serge	737	inc eax
		738	cmp eax,[TASK_COUNT] ;exit loop if we look through all processes
		739	jle .loop
164	serge	740
		741	;edx = number of threads
		742	;our process is zombi so it isn't counted
886	serge	743	cmp edx,1
		744	jg .exit
164	serge	745	;if there isn't threads then clear memory.
		746
886	serge	747	mov eax, [pg_dir]
839	serge	748	and eax, -4096
		749	add eax, OS_BASE
		750	mov [tmp_task_pdir], eax
		751	mov esi, eax
		752	mov edi, (HEAP_BASE shr 20)/4
164	serge	753	.destroy:
886	serge	754	mov eax, [esi]
		755	test eax, 1
		756	jz .next
		757	and eax, not 0xFFF
839	serge	758	add eax, OS_BASE
		759
		760	stdcall destroy_page_table, eax
		761
888	serge	762	mov ecx, [esi]
		763	call @core_free@4
164	serge	764	.next:
886	serge	765	add esi, 4
		766	dec edi
		767	jnz .destroy
164	serge	768
888	serge	769	mov ecx, [pg_dir]
		770	call @core_free@4
164	serge	771	.exit:
886	serge	772	dec [pg_data.pg_mutex]
		773	ret
164	serge	774	endp
		775
520	serge	776	align 4
		777	get_pid:
886	serge	778	mov eax, [TASK_BASE]
819	serge	779	mov eax, [eax+TASKDATA.pid]
886	serge	780	ret
520	serge	781
164	serge	782	pid_to_slot:
		783	;Input:
		784	; eax - pid of process
		785	;Output:
		786	; eax - slot of process or 0 if process don't exists
		787	;Search process by PID.
		788	push ebx
		789	push ecx
		790	mov ebx,[TASK_COUNT]
		791	shl ebx,5
		792	mov ecx,2*32
		793
		794	.loop:
		795	;ecx=offset of current process info entry
		796	;ebx=maximum permitted offset
		797	cmp byte [CURRENT_TASK+ecx+0xa],9
774	Rus	798	jz .endloop ;skip empty slots
164	serge	799	cmp [CURRENT_TASK+ecx+0x4],eax ;check PID
774	Rus	800	jz .pid_found
164	serge	801	.endloop:
		802	add ecx,32
		803	cmp ecx,ebx
		804	jle .loop
		805
		806	pop ecx
		807	pop ebx
		808	xor eax,eax
		809	ret
		810
		811	.pid_found:
		812	shr ecx,5
774	Rus	813	mov eax,ecx ;convert offset to index of slot
164	serge	814	pop ecx
		815	pop ebx
		816	ret
		817
		818	check_region:
		819	;input:
		820	; ebx - start of buffer
		821	; ecx - size of buffer
		822	;result:
		823	; eax = 1 region lays in app memory
		824	; eax = 0 region don't lays in app memory
		825	mov eax,[CURRENT_TASK]
		826	jmp check_process_region
		827	;-----------------------------------------------------------------------------
		828	check_process_region:
		829	;input:
		830	; eax - slot
		831	; ebx - start of buffer
		832	; ecx - size of buffer
		833	;result:
		834	; eax = 1 region lays in app memory
		835	; eax = 0 region don't lays in app memory
		836
		837	test ecx,ecx
		838	jle .ok
		839	shl eax,5
		840	cmp word [CURRENT_TASK+eax+0xa],0
		841	jnz .failed
		842	shl eax,3
380	serge	843	mov eax,[SLOT_BASE+eax+0xb8]
164	serge	844	test eax,eax
		845	jz .failed
		846
		847	mov eax,1
		848	ret
		849
		850	; call MEM_Get_Linear_Address
		851	; push ebx
		852	; push ecx
		853	; push edx
		854	; mov edx,ebx
		855	; and edx,not (4096-1)
		856	; sub ebx,edx
		857	; add ecx,ebx
		858	; mov ebx,edx
		859	; add ecx,(4096-1)
		860	; and ecx,not (4096-1)
		861	;.loop:
		862	;;eax - linear address of page directory
		863	;;ebx - current page
		864	;;ecx - current size
		865	; mov edx,ebx
		866	; shr edx,22
		867	; mov edx,[eax+4*edx]
		868	; and edx,not (4096-1)
		869	; test edx,edx
		870	; jz .failed1
		871	; push eax
		872	; mov eax,edx
		873	; call MEM_Get_Linear_Address
		874	; mov edx,ebx
		875	; shr edx,12
		876	; and edx,(1024-1)
		877	; mov eax,[eax+4*edx]
		878	; and eax,not (4096-1)
		879	; test eax,eax
		880	; pop eax
		881	; jz .failed1
		882	; add ebx,4096
		883	; sub ecx,4096
		884	; jg .loop
		885	; pop edx
		886	; pop ecx
		887	; pop ebx
		888	.ok:
		889	mov eax,1
		890	ret
		891	;
		892	;.failed1:
		893	; pop edx
		894	; pop ecx
		895	; pop ebx
		896	.failed:
		897	xor eax,eax
		898	ret
		899
		900	align 4
		901	proc read_process_memory
		902	;Input:
		903	; eax - process slot
		904	; ebx - buffer address
		905	; ecx - buffer size
		906	; edx - start address in other process
		907	;Output:
		908	; eax - number of bytes read.
774	Rus	909	locals
		910	slot dd ?
		911	buff dd ?
		912	r_count dd ?
		913	offset dd ?
		914	tmp_r_cnt dd ?
		915	endl
164	serge	916
774	Rus	917	mov [slot], eax
		918	mov [buff], ebx
		919	and [r_count], 0
		920	mov [tmp_r_cnt], ecx
		921	mov [offset], edx
164	serge	922
774	Rus	923	pushad
164	serge	924	.read_mem:
774	Rus	925	mov edx, [offset]
		926	mov ebx, [tmp_r_cnt]
164	serge	927
774	Rus	928	mov ecx, 0x400000
		929	and edx, 0x3FFFFF
		930	sub ecx, edx
		931	cmp ecx, ebx
		932	jbe @f
		933	mov ecx, ebx
164	serge	934	@@:
774	Rus	935	cmp ecx, 0x8000
		936	jna @F
		937	mov ecx, 0x8000
164	serge	938	@@:
774	Rus	939	mov eax, [slot]
		940	shl eax,8
		941	mov ebx, [offset]
		942	push ecx
		943	stdcall map_memEx, [proc_mem_map],\
		944	[SLOT_BASE+eax+0xB8],\
		945	ebx, ecx
		946	pop ecx
164	serge	947
774	Rus	948	mov esi, [offset]
		949	and esi, 0xfff
		950	add esi, [proc_mem_map]
		951	mov edi, [buff]
		952	mov edx, ecx
		953	rep movsb
		954	add [r_count], edx
164	serge	955
774	Rus	956	add [offset], edx
		957	sub [tmp_r_cnt], edx
		958	jnz .read_mem
164	serge	959
774	Rus	960	popad
		961	mov eax, [r_count]
		962	ret
164	serge	963	endp
		964
		965	align 4
		966	proc write_process_memory
		967	;Input:
		968	; eax - process slot
		969	; ebx - buffer address
		970	; ecx - buffer size
		971	; edx - start address in other process
		972	;Output:
		973	; eax - number of bytes written
		974
774	Rus	975	locals
		976	slot dd ?
		977	buff dd ?
		978	w_count dd ?
		979	offset dd ?
		980	tmp_w_cnt dd ?
		981	endl
164	serge	982
774	Rus	983	mov [slot], eax
		984	mov [buff], ebx
		985	and [w_count], 0
		986	mov [tmp_w_cnt], ecx
		987	mov [offset], edx
164	serge	988
774	Rus	989	pushad
164	serge	990	.read_mem:
774	Rus	991	mov edx, [offset]
		992	mov ebx, [tmp_w_cnt]
164	serge	993
774	Rus	994	mov ecx, 0x400000
		995	and edx, 0x3FFFFF
		996	sub ecx, edx
		997	cmp ecx, ebx
		998	jbe @f
		999	mov ecx, ebx
164	serge	1000	@@:
774	Rus	1001	cmp ecx, 0x8000
		1002	jna @F
		1003	mov ecx, 0x8000
164	serge	1004	@@:
774	Rus	1005	mov eax, [slot]
		1006	shl eax,8
		1007	mov ebx, [offset]
465	serge	1008	; add ebx, new_app_base
774	Rus	1009	push ecx
		1010	stdcall map_memEx, [proc_mem_map],\
		1011	[SLOT_BASE+eax+0xB8],\
		1012	ebx, ecx
		1013	pop ecx
164	serge	1014
774	Rus	1015	mov edi, [offset]
		1016	and edi, 0xfff
		1017	add edi, [proc_mem_map]
		1018	mov esi, [buff]
		1019	mov edx, ecx
		1020	rep movsb
164	serge	1021
774	Rus	1022	add [w_count], edx
		1023	add [offset], edx
		1024	sub [tmp_w_cnt], edx
		1025	jnz .read_mem
164	serge	1026
774	Rus	1027	popad
		1028	mov eax, [w_count]
		1029	ret
164	serge	1030	endp
		1031
		1032	align 4
		1033	proc new_sys_threads
886	serge	1034	locals
		1035	slot dd ?
		1036	app_cmdline dd ? ;0x00
		1037	app_path dd ? ;0x04
		1038	app_eip dd ? ;0x08
		1039	app_esp dd ? ;0x0C
		1040	app_mem dd ? ;0x10
		1041	endl
164	serge	1042
886	serge	1043	cmp eax,1
		1044	jne .failed ;other subfunctions
164	serge	1045
886	serge	1046	xor eax,eax
		1047	mov [app_cmdline], eax
		1048	mov [app_path], eax
		1049	mov [app_eip], ebx
		1050	mov [app_esp], ecx
164	serge	1051
886	serge	1052	;mov esi,new_process_loading
		1053	;call sys_msg_board_str
		1054	DEBUGF 1,"%s",new_process_loading
164	serge	1055	.wait_lock:
886	serge	1056	cmp [application_table_status],0
		1057	je .get_lock
164	serge	1058
886	serge	1059	call change_task
		1060	jmp .wait_lock
		1061
164	serge	1062	.get_lock:
886	serge	1063	mov eax, 1
		1064	xchg eax, [application_table_status]
		1065	cmp eax, 0
		1066	jne .wait_lock
164	serge	1067
886	serge	1068	call set_application_table_status
164	serge	1069
886	serge	1070	call get_new_process_place
		1071	test eax, eax
		1072	jz .failed
164	serge	1073
886	serge	1074	mov [slot], eax
164	serge	1075
886	serge	1076	mov esi,[current_slot]
		1077	mov ebx,esi ;ebx=esi - pointer to extended information about current thread
164	serge	1078
886	serge	1079	mov edi, eax
		1080	shl edi,8
		1081	add edi,SLOT_BASE
		1082	mov edx,edi ;edx=edi - pointer to extended infomation about new thread
		1083	mov ecx,256/4
		1084	xor eax, eax
		1085	cld
		1086	rep stosd ;clean extended information about new thread
		1087	mov esi,ebx
		1088	mov edi,edx
		1089	mov ecx,11
		1090	rep movsb ;copy process name
164	serge	1091
886	serge	1092	mov eax,[ebx+APPDATA.heap_base]
		1093	mov [edx+APPDATA.heap_base], eax
164	serge	1094
886	serge	1095	mov ecx,[ebx+APPDATA.heap_top]
		1096	mov [edx+APPDATA.heap_top], ecx
237	serge	1097
886	serge	1098	mov eax,[ebx+APPDATA.mem_size]
		1099	mov [edx+APPDATA.mem_size], eax
237	serge	1100
886	serge	1101	mov ecx,[ebx+APPDATA.dir_table]
		1102	mov [edx+APPDATA.dir_table],ecx ;copy page directory
237	serge	1103
886	serge	1104	lea eax, [app_cmdline]
		1105	stdcall set_app_params ,[slot],eax,dword 0,\
		1106	dword 0,dword 0
237	serge	1107
886	serge	1108	;mov esi,new_process_running
		1109	;call sys_msg_board_str ;output information about succefull startup
		1110	DEBUGF 1,"%s",new_process_running
164	serge	1111
886	serge	1112	mov [application_table_status],0 ;unlock application_table_status mutex
		1113	mov eax,[process_number] ;set result
		1114	ret
164	serge	1115	.failed:
886	serge	1116	mov [application_table_status],0
		1117	mov eax,-1
		1118	ret
164	serge	1119	endp
		1120
276	serge	1121	; param
		1122	; ebx=mutex
		1123
164	serge	1124	align 4
276	serge	1125	wait_mutex:
886	serge	1126	push eax
		1127	push ebx
321	diamond	1128	.do_wait:
886	serge	1129	cmp dword [ebx],0
		1130	je .get_lock
		1131
		1132	call change_task
		1133	jmp .do_wait
164	serge	1134	.get_lock:
886	serge	1135	mov eax, 1
		1136	xchg eax, [ebx]
		1137	test eax, eax
		1138	jnz .do_wait
164	serge	1139
886	serge	1140	pop ebx
		1141	pop eax
		1142	ret
		1143
465	serge	1144
		1145
237	serge	1146	align 4
		1147	proc set_app_params stdcall,slot:dword, params:dword,\
774	Rus	1148	cmd_line:dword, app_path:dword, flags:dword
164	serge	1149
886	serge	1150	locals
		1151	pl0_stack dd ?
		1152	endl
237	serge	1153
864	serge	1154	mov ecx, 1 ;(RING0_STACK_SIZE+512) shr 12
		1155	call @core_alloc@4
839	serge	1156	add eax, OS_BASE
886	serge	1157	mov [pl0_stack], eax
357	serge	1158
886	serge	1159	lea edi, [eax+RING0_STACK_SIZE]
357	serge	1160
886	serge	1161	mov eax, [slot]
		1162	mov ebx, eax
357	serge	1163
886	serge	1164	shl eax, 8
		1165	mov [eax+SLOT_BASE+APPDATA.fpu_state], edi
		1166	mov [eax+SLOT_BASE+APPDATA.fpu_handler], 0
		1167	mov [eax+SLOT_BASE+APPDATA.sse_handler], 0
357	serge	1168
465	serge	1169	;set default io permission map
886	serge	1170	mov [eax+SLOT_BASE+APPDATA.io_map],\
		1171	(tss._io_map_0-OS_BASE+PG_MAP)
		1172	mov [eax+SLOT_BASE+APPDATA.io_map+4],\
		1173	(tss._io_map_1-OS_BASE+PG_MAP)
465	serge	1174
886	serge	1175	mov esi, fpu_data
		1176	mov ecx, 512/4
		1177	rep movsd
237	serge	1178
886	serge	1179	cmp ebx,[TASK_COUNT]
		1180	jle .noinc
		1181	inc dword [TASK_COUNT] ;update number of processes
237	serge	1182	.noinc:
886	serge	1183	shl ebx,8
		1184	lea edx, [ebx+SLOT_BASE+APP_EV_OFFSET]
		1185	mov [SLOT_BASE+APPDATA.fd_ev+ebx],edx
		1186	mov [SLOT_BASE+APPDATA.bk_ev+ebx],edx
354	serge	1187
886	serge	1188	add edx, APP_OBJ_OFFSET-APP_EV_OFFSET
		1189	mov [SLOT_BASE+APPDATA.fd_obj+ebx],edx
		1190	mov [SLOT_BASE+APPDATA.bk_obj+ebx],edx
237	serge	1191
886	serge	1192	mov ecx, [def_cursor]
		1193	mov [SLOT_BASE+APPDATA.cursor+ebx],ecx
		1194	mov eax, [pl0_stack]
		1195	mov [SLOT_BASE+APPDATA.pl0_stack+ebx],eax
		1196	add eax, RING0_STACK_SIZE
		1197	mov [SLOT_BASE+APPDATA.saved_esp0+ebx], eax
281	serge	1198
854	serge	1199	call _alloc_page
839	serge	1200	add eax, OS_BASE
886	serge	1201	mov esi,[current_slot]
		1202	mov esi,[esi+APPDATA.cur_dir]
		1203	mov ecx,0x1000/4
		1204	mov edi,eax
		1205	mov [ebx+SLOT_BASE+APPDATA.cur_dir],eax
		1206	rep movsd
521	diamond	1207
886	serge	1208	shr ebx,3
840	serge	1209	mov dword [CURRENT_TASK+ebx+0x10], 0
237	serge	1210
		1211	.add_command_line:
886	serge	1212	mov edx,[params]
		1213	mov edx,[edx] ;app_cmdline
		1214	test edx,edx
		1215	jz @f ;application doesn't need parameters
281	serge	1216
886	serge	1217	mov eax, edx
		1218	add eax, 256
		1219	jc @f
281	serge	1220
886	serge	1221	cmp eax, [SLOT_BASE+APPDATA.mem_size+ebx*8]
		1222	ja @f
281	serge	1223
886	serge	1224	mov byte [edx], 0 ;force empty string if no cmdline given
		1225	mov eax, [cmd_line]
		1226	test eax, eax
		1227	jz @f
		1228	stdcall strncpy, edx, eax, 256
237	serge	1229	@@:
886	serge	1230	mov edx,[params]
		1231	mov edx, [edx+4] ;app_path
		1232	test edx,edx
		1233	jz @F ;application don't need path of file
		1234	mov eax, edx
		1235	add eax, 1024
		1236	jc @f
		1237	cmp eax, [SLOT_BASE+APPDATA.mem_size+ebx*8]
		1238	ja @f
		1239	stdcall strncpy, edx, [app_path], 1024
237	serge	1240	@@:
886	serge	1241	mov ebx,[slot]
		1242	mov eax,ebx
		1243	shl ebx,5
		1244	lea ecx,[draw_data+ebx] ;ecx - pointer to draw data
465	serge	1245
237	serge	1246	; set window state to 'normal' (non-minimized/maximized/rolled-up) state
886	serge	1247	mov [ebx+window_data+WDATA.fl_wstate], WSTATE_NORMAL
		1248	mov [ebx+window_data+WDATA.fl_redraw], 1
		1249	add ebx,CURRENT_TASK ;ebx - pointer to information about process
		1250	mov [ebx+TASKDATA.wnd_number],al;set window number on screen = process slot
237	serge	1251
886	serge	1252	mov [ebx+TASKDATA.event_mask],dword 1+2+4 ;set default event flags (see 40 function)
237	serge	1253
886	serge	1254	inc dword [process_number]
		1255	mov eax,[process_number]
		1256	mov [ebx+4],eax ;set PID
237	serge	1257
		1258	;set draw data to full screen
		1259
886	serge	1260	mov [ecx+0],dword 0
		1261	mov [ecx+4],dword 0
		1262	mov eax,[Screen_Max_X]
		1263	mov [ecx+8],eax
		1264	mov eax,[Screen_Max_Y]
		1265	mov [ecx+12],eax
237	serge	1266
886	serge	1267	mov ebx, [pl0_stack]
		1268	mov esi,[params]
		1269	lea ecx, [ebx+REG_EIP]
		1270	xor eax, eax
237	serge	1271
886	serge	1272	mov [ebx+REG_RET], dword irq0.return
		1273	mov [ebx+REG_EDI], eax
		1274	mov [ebx+REG_ESI], eax
		1275	mov [ebx+REG_EBP], eax
		1276	mov [ebx+REG_ESP], ecx ;ebx+REG_EIP
		1277	mov [ebx+REG_EBX], eax
		1278	mov [ebx+REG_EDX], eax
		1279	mov [ebx+REG_ECX], eax
		1280	mov [ebx+REG_EAX], eax
237	serge	1281
886	serge	1282	mov eax, [esi+0x08] ;app_eip
		1283	mov [ebx+REG_EIP], eax ;app_entry
928	serge	1284	mov [ebx+REG_CS], dword sel_app_code
886	serge	1285	mov [ebx+REG_EFLAGS], dword EFL_IOPL3+EFL_IF
465	serge	1286
886	serge	1287	mov eax, [esi+0x0C] ;app_esp
		1288	mov [ebx+REG_APP_ESP], eax ;app_stack
928	serge	1289	mov [ebx+REG_SS], dword sel_app_data
237	serge	1290
886	serge	1291	lea ecx, [ebx+REG_RET]
		1292	mov ebx, [slot]
		1293	shl ebx, 5
		1294	mov [ebx*8+SLOT_BASE+APPDATA.saved_esp], ecx
237	serge	1295
886	serge	1296	xor ecx, ecx ; process state - running
237	serge	1297	; set if debuggee
886	serge	1298	test byte [flags], 1
		1299	jz .no_debug
		1300
		1301	inc ecx ; process state - suspended
		1302	mov eax,[CURRENT_TASK]
		1303	mov [SLOT_BASE+ebx*8+APPDATA.debugger_slot],eax
237	serge	1304	.no_debug:
886	serge	1305	mov [CURRENT_TASK+ebx+TASKDATA.state], cl
		1306	DEBUGF 1,"%s",new_process_running
		1307	ret
237	serge	1308	endp
		1309
164	serge	1310	include "debug.inc"

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri_pe/core/taskman.inc – Rev 928