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

Subversion Repositories Kolibri OS

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