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: 1066 $
		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
1066	serge	225	mov ecx,[hdr_mem]
		226	mov [ebx+APPDATA.mem_size],ecx
237	serge	227
886	serge	228	mov edi, [file_size]
914	serge	229	; add edi, 4095
		230	; and edi, not 4095
886	serge	231	sub ecx, edi
		232	jna @F
269	serge	233
886	serge	234	xor eax, eax
889	serge	235	cld
886	serge	236	rep stosb
247	serge	237	@@:
888	serge	238	mov ecx, [file_base]
		239	call @mem_free@4
269	serge	240
886	serge	241	lea eax, [hdr_cmdline]
		242	lea ebx, [cmdline]
		243	lea ecx, [filename]
		244	stdcall set_app_params ,[slot],eax,ebx,ecx,[flags]
237	serge	245
886	serge	246	mov eax, [save_cr3]
		247	call set_cr3
237	serge	248
914	serge	249	mov eax,[process_number] ;set result
897	serge	250	mov [application_table_status], 0 ;unlock application_table_status mutex
		251
		252	pop edi
		253	pop esi
		254	pop ebx
		255
886	serge	256	ret
897	serge	257
		258	.bigfilename:
		259	pop edi
		260	pop esi
		261	pop ebx
		262	mov eax, -ERROR_FILE_NOT_FOUND
		263	ret
237	serge	264	.failed:
886	serge	265	mov eax, [save_cr3]
		266	call set_cr3
269	serge	267	.err:
247	serge	268	.err_hdr:
887	serge	269	mov ecx, [file_base]
		270	call @mem_free@4
897	serge	271
		272	pop edi
		273	pop esi
		274	pop ebx
		275
886	serge	276	xor eax, eax
		277	mov [application_table_status],eax
		278	mov eax, ecx
		279	ret
237	serge	280	endp
164	serge	281
237	serge	282	align 4
908	serge	283	proc pe_app_param stdcall path:dword, raw:dword, ex_pg_dir:dword, ex_stack:dword
164	serge	284
897	serge	285	locals
		286	slot dd ?
		287	slot_base dd ?
908	serge	288	pl0_stack dd ?
897	serge	289	endl
164	serge	290
897	serge	291	push ebx
		292	push esi
		293	push edi
164	serge	294
897	serge	295	lea ebx, [application_table_status]
		296	call wait_mutex
164	serge	297
897	serge	298	call set_application_table_status
164	serge	299
897	serge	300	call get_new_process_place
		301	test eax, eax
		302	mov ecx, -0x20 ; too many processes
		303	jz .err
237	serge	304
897	serge	305	mov [slot], eax
		306	shl eax, 8
		307	add eax, SLOT_BASE
		308	mov [slot_base], eax
		309	mov edi, eax
		310	_clear_ 256 ;clean extended information about process
381	serge	311
897	serge	312	; write application name
908	serge	313	stdcall strrchr, [path], '/' ; now eax points to name without path
897	serge	314	lea esi, [eax+1]
		315	test eax, eax
		316	jnz @F
		317	lea esi, [path]
		318	@@:
		319	mov ecx, 8 ; 8 chars for name
		320	mov edi, [slot_base]
		321	.copy_process_name_loop:
		322	lodsb
		323	cmp al, '.'
		324	jz .copy_process_name_done
		325	test al, al
		326	jz .copy_process_name_done
		327	stosb
		328	loop .copy_process_name_loop
		329	.copy_process_name_done:
381	serge	330
897	serge	331	mov eax, [ex_pg_dir]
		332	mov ebx, [slot_base]
		333	mov [ebx+APPDATA.dir_table],eax
		334
		335	;mov eax,[hdr_mem]
		336	;mov [ebx+APPDATA.mem_size],eax
		337
		338
1066	serge	339	mov ecx, 2
		340	call @frame_alloc@4
908	serge	341	lea edi, [eax+OS_BASE]
		342	mov [pl0_stack], edi
		343
897	serge	344	mov [ebx+APPDATA.pl0_stack], edi
		345	add edi, RING0_STACK_SIZE
		346	mov [ebx+APPDATA.saved_esp0], edi
		347	mov [ebx+APPDATA.fpu_state], edi
		348	mov [ebx+APPDATA.fpu_handler], 0
		349	mov [ebx+APPDATA.sse_handler], 0
		350
		351	;set default io permission map
		352	mov [ebx+APPDATA.io_map],\
		353	(tss._io_map_0-OS_BASE+PG_MAP)
		354	mov [ebx+APPDATA.io_map+4],\
		355	(tss._io_map_1-OS_BASE+PG_MAP)
		356
		357	mov esi, fpu_data
		358	mov ecx, 512/4
		359	rep movsd
		360
		361	mov eax, [slot]
		362	cmp eax,[TASK_COUNT]
		363	jle .noinc
		364	inc dword [TASK_COUNT] ;update number of processes
		365	.noinc:
		366	lea edx, [ebx+APP_EV_OFFSET]
		367	mov [ebx+APPDATA.fd_ev],edx
		368	mov [ebx+APPDATA.bk_ev],edx
		369
		370	add edx, APP_OBJ_OFFSET-APP_EV_OFFSET
		371	mov [ebx+APPDATA.fd_obj],edx
		372	mov [ebx+APPDATA.bk_obj],edx
		373
		374	mov ecx, [def_cursor]
		375	mov [ebx+APPDATA.cursor],ecx
		376
1066	serge	377	call _alloc_page
908	serge	378	lea edi, [eax+OS_BASE] ; FIXME
897	serge	379
		380	mov esi,[current_slot]
		381	mov esi,[esi+APPDATA.cur_dir]
		382	mov ecx,0x1000/4
908	serge	383	mov [ebx+APPDATA.cur_dir],edi
897	serge	384	rep movsd
		385
		386	mov ebx, [slot]
		387	mov eax, ebx
		388	shl ebx, 5
		389	mov dword [CURRENT_TASK+ebx+0x10], 0
		390
		391	lea ecx,[draw_data+ebx] ;ecx - pointer to draw data
		392
		393	; set window state to 'normal' (non-minimized/maximized/rolled-up) state
		394	mov [ebx+window_data+WDATA.fl_wstate], WSTATE_NORMAL
		395	mov [ebx+window_data+WDATA.fl_redraw], 1
		396	add ebx,CURRENT_TASK ;ebx - pointer to information about process
		397	mov [ebx+TASKDATA.wnd_number],al;set window number on screen = process slot
		398
		399	mov [ebx+TASKDATA.event_mask],dword 1+2+4 ;set default event flags (see 40 function)
		400
		401	inc dword [process_number]
		402	mov eax,[process_number]
		403	mov [ebx+4],eax ;set PID
		404
		405	;set draw data to full screen
		406
		407	mov [ecx+0],dword 0
		408	mov [ecx+4],dword 0
		409	mov eax,[Screen_Max_X]
		410	mov [ecx+8],eax
		411	mov eax,[Screen_Max_Y]
		412	mov [ecx+12],eax
		413
908	serge	414	mov ebx, [pl0_stack]
897	serge	415
		416	mov eax, [raw]
908	serge	417	lea ecx, [ebx+REG_EDI]
		418	mov edx, [ex_stack]
897	serge	419
908	serge	420	mov [ebx+REG_ENTRY], dword _sys_app_entry
		421	mov [ebx+REG_RESTART], dword _pe_restart
		422	mov [ebx+REG_RAW], eax
		423	mov [ebx+REG_CSTACK], ecx
		424	mov [ebx+REG_USTACK], edx
		425
		426	lea ebx, [ebx+REG_ENTRY]
		427
897	serge	428	mov ecx, [slot]
		429	shl ecx, 5
		430	mov [ecx*8+SLOT_BASE+APPDATA.saved_esp], ebx
908	serge	431	mov [CURRENT_TASK+ecx+TASKDATA.state], 0
897	serge	432
996	serge	433	; DEBUGF 1,"%s",new_process_running
897	serge	434	.err:
914	serge	435	mov eax,[process_number] ;set result
897	serge	436	mov [application_table_status], 0 ;unlock application_table_status mutex
		437
		438	pop edi
		439	pop esi
		440	pop ebx
		441
774	Rus	442	ret
897	serge	443	endp
164	serge	444
908	serge	445	align 4
		446	_pe_restart:
		447	add esp, 12
		448	popad
		449	iretd
897	serge	450
908	serge	451
164	serge	452	align 4
		453	proc get_new_process_place
		454	;input:
		455	; none
		456	;result:
		457	; eax=[new_process_place]<>0 - ok
		458	; 0 - failed.
		459	;This function find least empty slot.
		460	;It doesn't increase [TASK_COUNT]!
774	Rus	461	mov eax,CURRENT_TASK
		462	mov ebx,[TASK_COUNT]
		463	inc ebx
		464	shl ebx,5
		465	add ebx,eax ;ebx - address of process information for (last+1) slot
164	serge	466	.newprocessplace:
		467	;eax = address of process information for current slot
774	Rus	468	cmp eax,ebx
		469	jz .endnewprocessplace ;empty slot after high boundary
		470	add eax,0x20
		471	cmp word [eax+0xa],9 ;check process state, 9 means that process slot is empty
		472	jnz .newprocessplace
164	serge	473	.endnewprocessplace:
774	Rus	474	mov ebx,eax
		475	sub eax,CURRENT_TASK
		476	shr eax,5 ;calculate slot index
		477	cmp eax,256
		478	jge .failed ;it should be <256
		479	mov word [ebx+0xa],9 ;set process state to 9 (for slot after hight boundary)
		480	ret
164	serge	481	.failed:
774	Rus	482	xor eax,eax
		483	ret
164	serge	484	endp
		485
		486	align 4
269	serge	487	proc create_app_space stdcall, app_size:dword,img_base:dword,img_size:dword
886	serge	488	locals
		489	app_pages dd ?
		490	img_pages dd ?
		491	dir_addr dd ?
		492	app_tabs dd ?
		493	endl
164	serge	494
886	serge	495	mov ebx, pg_data.pg_mutex
		496	call wait_mutex ;ebx
164	serge	497
886	serge	498	xor eax, eax
		499	mov [dir_addr], eax
164	serge	500
886	serge	501	mov eax, [app_size]
		502	add eax, 4095
861	serge	503	and eax, not 4095
886	serge	504	mov [app_size], eax
		505	mov ebx, eax
		506	shr eax, 12
		507	mov [app_pages], eax
170	serge	508
886	serge	509	add ebx, 0x3FFFFF
861	serge	510	and ebx, not 0x3FFFFF
886	serge	511	shr ebx, 22
		512	mov [app_tabs], ebx
164	serge	513
886	serge	514	mov ecx, [img_size]
		515	add ecx, 4095
861	serge	516	and ecx, not 4095
164	serge	517
886	serge	518	mov [img_size], ecx
		519	shr ecx, 12
		520	mov [img_pages], ecx
164	serge	521
854	serge	522	call _alloc_page
886	serge	523	test eax, eax
		524	mov [dir_addr], eax
		525	jz .fail
164	serge	526
861	serge	527	;lea edi, [eax + OS_BASE]
		528	;mov ecx, (OS_BASE shr 20)/4
		529	;xor eax, eax
		530	;cld
		531	;rep stosd
465	serge	532
861	serge	533	;mov ecx, 1024-(OS_BASE shr 20)/4
		534	;mov esi, _sys_pdbr+(OS_BASE shr 20)
		535	;rep movsd
164	serge	536
861	serge	537	lea edi, [eax+OS_BASE]
		538	mov ecx, 512
		539	xor eax, eax
		540	cld
		541	rep stosd
		542
1066	serge	543	mov esi, [img_base]
		544
		545	mov ecx, 512 ; FIX only core tabs
861	serge	546	mov esi, _sys_pdbr+(HEAP_BASE shr 20)
		547	rep movsd
		548
839	serge	549	mov edi, [dir_addr]
		550	lea eax, [edi+PG_SW]
		551	mov [edi+OS_BASE+(page_tabs shr 20)], eax
378	serge	552
861	serge	553	mov eax, edi
886	serge	554	call set_cr3
164	serge	555
1066	serge	556	mov esi, [img_base]
		557
		558	mov ebx, [app_tabs]
861	serge	559	mov edi, master_tab
164	serge	560	@@:
854	serge	561	call _alloc_page
886	serge	562	test eax, eax
		563	jz .fail
164	serge	564
861	serge	565	or eax, PG_UW
		566	stosd
1066	serge	567	dec ebx
861	serge	568	jnz @B
164	serge	569
839	serge	570	mov edi, page_tabs
886	serge	571	mov ecx, [app_tabs]
		572	shl ecx, 10
		573	xor eax, eax
		574	rep stosd
164	serge	575
888	serge	576	xor ebx, ebx
164	serge	577	.alloc:
1066	serge	578	call _alloc_page
886	serge	579	test eax, eax
		580	jz .fail
164	serge	581
888	serge	582	stdcall map_page,ebx,eax,dword PG_UW
		583	add ebx, 0x1000
886	serge	584	dec [app_pages]
		585	jnz .alloc
164	serge	586
888	serge	587	mov ecx, [img_size] ; FIXME remap md
		588	mov esi, [img_base]
		589	xor edi, edi
		590
		591	rep movsb
		592
269	serge	593	.done:
839	serge	594	dec [pg_data.pg_mutex]
886	serge	595	mov eax, [dir_addr]
		596	ret
164	serge	597	.fail:
886	serge	598	dec [pg_data.pg_mutex]
		599	cmp [dir_addr], 0
		600	je @f
		601	stdcall destroy_app_space, [dir_addr]
164	serge	602	@@:
886	serge	603	xor eax, eax
		604	ret
164	serge	605	endp
		606
908	serge	607	;addr_t __fastcall pe_app_space(size_t size);
164	serge	608	align 4
908	serge	609	@pe_app_space@4:
		610	sub esp, 16
		611
		612	mov [esp+4], ebx
		613	mov [esp+8], esi
		614	mov [esp+12], edi
		615
		616	lea ebx, [ecx+0x3FFFFF]
		617
1066	serge	618	call _alloc_page
897	serge	619	test eax, eax
908	serge	620	mov [esp], eax
897	serge	621	jz .fail
		622
		623	mov ecx, 512
		624	lea edi, [eax + OS_BASE]
		625	xor eax, eax
		626	cld
		627	rep stosd
		628
1066	serge	629	mov ecx, 512 ; FIX only core tabs
897	serge	630	mov esi, _sys_pdbr+(HEAP_BASE shr 20)
		631	rep movsd
		632
908	serge	633	mov esi, [esp]
		634	shr ebx, 22
		635	.new_ptab:
1066	serge	636	call _alloc_page
908	serge	637	test eax, eax
		638	jz .fail
897	serge	639
908	serge	640	lea edi, [eax+OS_BASE]
		641	or eax, PG_UW
		642	mov [esi+OS_BASE], eax
897	serge	643
908	serge	644	mov ecx, 1024
897	serge	645	xor eax, eax
		646	rep stosd
		647
908	serge	648	add esi, 4
		649	dec ebx
		650	jnz .new_ptab
		651
1066	serge	652	call _alloc_page
908	serge	653	test eax, eax
		654	jz .fail
		655
		656	lea edi, [eax+OS_BASE]
		657	or eax, PG_UW
		658
		659	mov ebx, [esp]
		660	lea edx, [ebx+PG_SW]
		661	mov [ebx+OS_BASE+(0x7FC00000 shr 20)], eax
		662	mov [ebx+OS_BASE+(page_tabs shr 20)], edx
		663
		664	mov ecx, 1024
		665	xor eax, eax
		666	rep stosd
		667
		668	mov eax, ebx
897	serge	669	.fail:
908	serge	670	mov ebx, [esp+4]
		671	mov esi, [esp+8]
		672	mov edi, [esp+12]
		673
		674	add esp, 16
897	serge	675	ret
		676
		677	align 4
164	serge	678	set_cr3:
465	serge	679
886	serge	680	mov ebx, [current_slot]
		681	mov [ebx+APPDATA.dir_table], eax
		682	mov cr3, eax
		683	ret
164	serge	684
		685	align 4
		686	proc destroy_page_table stdcall, pg_tab:dword
		687
888	serge	688	push ebx
886	serge	689	push esi
164	serge	690
886	serge	691	mov esi, [pg_tab]
888	serge	692	mov ebx, 1024
164	serge	693	.free:
888	serge	694	mov ecx, [esi]
		695	test ecx, 1
886	serge	696	jz .next
		697
888	serge	698	test ecx, 1 shl 9
819	serge	699	jnz .next ;skip shared pages
886	serge	700
1066	serge	701	call @frame_free@4
164	serge	702	.next:
886	serge	703	add esi, 4
888	serge	704	dec ebx
886	serge	705	jnz .free
		706	pop esi
888	serge	707	pop ebx
886	serge	708	ret
164	serge	709	endp
		710
		711	align 4
		712	proc destroy_app_space stdcall, pg_dir:dword
		713
886	serge	714	mov ebx, pg_data.pg_mutex
		715	call wait_mutex ;ebx
164	serge	716
886	serge	717	xor edx,edx
		718	mov eax,0x2
		719	mov ebx, [pg_dir]
164	serge	720	.loop:
		721	;eax = current slot of process
886	serge	722	mov ecx,eax
		723	shl ecx,5
		724	cmp byte [CURRENT_TASK+ecx+0xa],9 ;if process running?
		725	jz @f ;skip empty slots
		726
		727	shl ecx,3
		728	cmp [SLOT_BASE+ecx+0xB8],ebx ;compare page directory addresses
		729	jnz @f
		730
		731	inc edx ;thread found
164	serge	732	@@:
886	serge	733	inc eax
		734	cmp eax,[TASK_COUNT] ;exit loop if we look through all processes
		735	jle .loop
164	serge	736
		737	;edx = number of threads
		738	;our process is zombi so it isn't counted
886	serge	739	cmp edx,1
		740	jg .exit
164	serge	741	;if there isn't threads then clear memory.
		742
886	serge	743	mov eax, [pg_dir]
839	serge	744	and eax, -4096
		745	add eax, OS_BASE
		746	mov [tmp_task_pdir], eax
		747	mov esi, eax
		748	mov edi, (HEAP_BASE shr 20)/4
164	serge	749	.destroy:
886	serge	750	mov eax, [esi]
		751	test eax, 1
		752	jz .next
		753	and eax, not 0xFFF
839	serge	754	add eax, OS_BASE
		755
		756	stdcall destroy_page_table, eax
		757
888	serge	758	mov ecx, [esi]
1066	serge	759	call @frame_free@4
164	serge	760	.next:
886	serge	761	add esi, 4
		762	dec edi
		763	jnz .destroy
164	serge	764
888	serge	765	mov ecx, [pg_dir]
1066	serge	766	call @frame_free@4
164	serge	767	.exit:
886	serge	768	dec [pg_data.pg_mutex]
		769	ret
164	serge	770	endp
		771
520	serge	772	align 4
		773	get_pid:
886	serge	774	mov eax, [TASK_BASE]
819	serge	775	mov eax, [eax+TASKDATA.pid]
886	serge	776	ret
520	serge	777
164	serge	778	pid_to_slot:
		779	;Input:
		780	; eax - pid of process
		781	;Output:
		782	; eax - slot of process or 0 if process don't exists
		783	;Search process by PID.
		784	push ebx
		785	push ecx
		786	mov ebx,[TASK_COUNT]
		787	shl ebx,5
		788	mov ecx,2*32
		789
		790	.loop:
		791	;ecx=offset of current process info entry
		792	;ebx=maximum permitted offset
		793	cmp byte [CURRENT_TASK+ecx+0xa],9
774	Rus	794	jz .endloop ;skip empty slots
164	serge	795	cmp [CURRENT_TASK+ecx+0x4],eax ;check PID
774	Rus	796	jz .pid_found
164	serge	797	.endloop:
		798	add ecx,32
		799	cmp ecx,ebx
		800	jle .loop
		801
		802	pop ecx
		803	pop ebx
		804	xor eax,eax
		805	ret
		806
		807	.pid_found:
		808	shr ecx,5
774	Rus	809	mov eax,ecx ;convert offset to index of slot
164	serge	810	pop ecx
		811	pop ebx
		812	ret
		813
		814	check_region:
		815	;input:
		816	; ebx - start of buffer
		817	; ecx - size of buffer
		818	;result:
		819	; eax = 1 region lays in app memory
		820	; eax = 0 region don't lays in app memory
		821	mov eax,[CURRENT_TASK]
		822	jmp check_process_region
		823	;-----------------------------------------------------------------------------
		824	check_process_region:
		825	;input:
		826	; eax - slot
		827	; ebx - start of buffer
		828	; ecx - size of buffer
		829	;result:
		830	; eax = 1 region lays in app memory
		831	; eax = 0 region don't lays in app memory
		832
		833	test ecx,ecx
		834	jle .ok
		835	shl eax,5
		836	cmp word [CURRENT_TASK+eax+0xa],0
		837	jnz .failed
		838	shl eax,3
380	serge	839	mov eax,[SLOT_BASE+eax+0xb8]
164	serge	840	test eax,eax
		841	jz .failed
		842
		843	mov eax,1
		844	ret
		845
		846	; call MEM_Get_Linear_Address
		847	; push ebx
		848	; push ecx
		849	; push edx
		850	; mov edx,ebx
		851	; and edx,not (4096-1)
		852	; sub ebx,edx
		853	; add ecx,ebx
		854	; mov ebx,edx
		855	; add ecx,(4096-1)
		856	; and ecx,not (4096-1)
		857	;.loop:
		858	;;eax - linear address of page directory
		859	;;ebx - current page
		860	;;ecx - current size
		861	; mov edx,ebx
		862	; shr edx,22
		863	; mov edx,[eax+4*edx]
		864	; and edx,not (4096-1)
		865	; test edx,edx
		866	; jz .failed1
		867	; push eax
		868	; mov eax,edx
		869	; call MEM_Get_Linear_Address
		870	; mov edx,ebx
		871	; shr edx,12
		872	; and edx,(1024-1)
		873	; mov eax,[eax+4*edx]
		874	; and eax,not (4096-1)
		875	; test eax,eax
		876	; pop eax
		877	; jz .failed1
		878	; add ebx,4096
		879	; sub ecx,4096
		880	; jg .loop
		881	; pop edx
		882	; pop ecx
		883	; pop ebx
		884	.ok:
		885	mov eax,1
		886	ret
		887	;
		888	;.failed1:
		889	; pop edx
		890	; pop ecx
		891	; pop ebx
		892	.failed:
		893	xor eax,eax
		894	ret
		895
		896	align 4
		897	proc read_process_memory
		898	;Input:
		899	; eax - process slot
		900	; ebx - buffer address
		901	; ecx - buffer size
		902	; edx - start address in other process
		903	;Output:
		904	; eax - number of bytes read.
774	Rus	905	locals
		906	slot dd ?
		907	buff dd ?
		908	r_count dd ?
		909	offset dd ?
		910	tmp_r_cnt dd ?
		911	endl
164	serge	912
774	Rus	913	mov [slot], eax
		914	mov [buff], ebx
		915	and [r_count], 0
		916	mov [tmp_r_cnt], ecx
		917	mov [offset], edx
164	serge	918
774	Rus	919	pushad
164	serge	920	.read_mem:
774	Rus	921	mov edx, [offset]
		922	mov ebx, [tmp_r_cnt]
164	serge	923
774	Rus	924	mov ecx, 0x400000
		925	and edx, 0x3FFFFF
		926	sub ecx, edx
		927	cmp ecx, ebx
		928	jbe @f
		929	mov ecx, ebx
164	serge	930	@@:
774	Rus	931	cmp ecx, 0x8000
		932	jna @F
		933	mov ecx, 0x8000
164	serge	934	@@:
774	Rus	935	mov eax, [slot]
		936	shl eax,8
		937	mov ebx, [offset]
		938	push ecx
		939	stdcall map_memEx, [proc_mem_map],\
		940	[SLOT_BASE+eax+0xB8],\
		941	ebx, ecx
		942	pop ecx
164	serge	943
774	Rus	944	mov esi, [offset]
		945	and esi, 0xfff
		946	add esi, [proc_mem_map]
		947	mov edi, [buff]
		948	mov edx, ecx
		949	rep movsb
		950	add [r_count], edx
164	serge	951
774	Rus	952	add [offset], edx
		953	sub [tmp_r_cnt], edx
		954	jnz .read_mem
164	serge	955
774	Rus	956	popad
		957	mov eax, [r_count]
		958	ret
164	serge	959	endp
		960
		961	align 4
		962	proc write_process_memory
		963	;Input:
		964	; eax - process slot
		965	; ebx - buffer address
		966	; ecx - buffer size
		967	; edx - start address in other process
		968	;Output:
		969	; eax - number of bytes written
		970
774	Rus	971	locals
		972	slot dd ?
		973	buff dd ?
		974	w_count dd ?
		975	offset dd ?
		976	tmp_w_cnt dd ?
		977	endl
164	serge	978
774	Rus	979	mov [slot], eax
		980	mov [buff], ebx
		981	and [w_count], 0
		982	mov [tmp_w_cnt], ecx
		983	mov [offset], edx
164	serge	984
774	Rus	985	pushad
164	serge	986	.read_mem:
774	Rus	987	mov edx, [offset]
		988	mov ebx, [tmp_w_cnt]
164	serge	989
774	Rus	990	mov ecx, 0x400000
		991	and edx, 0x3FFFFF
		992	sub ecx, edx
		993	cmp ecx, ebx
		994	jbe @f
		995	mov ecx, ebx
164	serge	996	@@:
774	Rus	997	cmp ecx, 0x8000
		998	jna @F
		999	mov ecx, 0x8000
164	serge	1000	@@:
774	Rus	1001	mov eax, [slot]
		1002	shl eax,8
		1003	mov ebx, [offset]
465	serge	1004	; add ebx, new_app_base
774	Rus	1005	push ecx
		1006	stdcall map_memEx, [proc_mem_map],\
		1007	[SLOT_BASE+eax+0xB8],\
		1008	ebx, ecx
		1009	pop ecx
164	serge	1010
774	Rus	1011	mov edi, [offset]
		1012	and edi, 0xfff
		1013	add edi, [proc_mem_map]
		1014	mov esi, [buff]
		1015	mov edx, ecx
		1016	rep movsb
164	serge	1017
774	Rus	1018	add [w_count], edx
		1019	add [offset], edx
		1020	sub [tmp_w_cnt], edx
		1021	jnz .read_mem
164	serge	1022
774	Rus	1023	popad
		1024	mov eax, [w_count]
		1025	ret
164	serge	1026	endp
		1027
		1028	align 4
		1029	proc new_sys_threads
886	serge	1030	locals
		1031	slot dd ?
		1032	app_cmdline dd ? ;0x00
		1033	app_path dd ? ;0x04
		1034	app_eip dd ? ;0x08
		1035	app_esp dd ? ;0x0C
		1036	app_mem dd ? ;0x10
		1037	endl
164	serge	1038
886	serge	1039	cmp eax,1
		1040	jne .failed ;other subfunctions
164	serge	1041
886	serge	1042	xor eax,eax
		1043	mov [app_cmdline], eax
		1044	mov [app_path], eax
		1045	mov [app_eip], ebx
		1046	mov [app_esp], ecx
164	serge	1047
886	serge	1048	;mov esi,new_process_loading
		1049	;call sys_msg_board_str
		1050	DEBUGF 1,"%s",new_process_loading
164	serge	1051	.wait_lock:
886	serge	1052	cmp [application_table_status],0
		1053	je .get_lock
164	serge	1054
886	serge	1055	call change_task
		1056	jmp .wait_lock
		1057
164	serge	1058	.get_lock:
886	serge	1059	mov eax, 1
		1060	xchg eax, [application_table_status]
		1061	cmp eax, 0
		1062	jne .wait_lock
164	serge	1063
886	serge	1064	call set_application_table_status
164	serge	1065
886	serge	1066	call get_new_process_place
		1067	test eax, eax
		1068	jz .failed
164	serge	1069
886	serge	1070	mov [slot], eax
164	serge	1071
886	serge	1072	mov esi,[current_slot]
		1073	mov ebx,esi ;ebx=esi - pointer to extended information about current thread
164	serge	1074
886	serge	1075	mov edi, eax
		1076	shl edi,8
		1077	add edi,SLOT_BASE
		1078	mov edx,edi ;edx=edi - pointer to extended infomation about new thread
		1079	mov ecx,256/4
		1080	xor eax, eax
		1081	cld
		1082	rep stosd ;clean extended information about new thread
		1083	mov esi,ebx
		1084	mov edi,edx
		1085	mov ecx,11
		1086	rep movsb ;copy process name
164	serge	1087
886	serge	1088	mov eax,[ebx+APPDATA.heap_base]
		1089	mov [edx+APPDATA.heap_base], eax
164	serge	1090
886	serge	1091	mov ecx,[ebx+APPDATA.heap_top]
		1092	mov [edx+APPDATA.heap_top], ecx
237	serge	1093
886	serge	1094	mov eax,[ebx+APPDATA.mem_size]
		1095	mov [edx+APPDATA.mem_size], eax
237	serge	1096
886	serge	1097	mov ecx,[ebx+APPDATA.dir_table]
		1098	mov [edx+APPDATA.dir_table],ecx ;copy page directory
237	serge	1099
886	serge	1100	lea eax, [app_cmdline]
		1101	stdcall set_app_params ,[slot],eax,dword 0,\
		1102	dword 0,dword 0
237	serge	1103
886	serge	1104	;mov esi,new_process_running
		1105	;call sys_msg_board_str ;output information about succefull startup
		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
		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
		1228	jz @F ;application don't need path of file
		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
886	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
886	serge	1280	mov [ebx+REG_EFLAGS], dword EFL_IOPL3+EFL_IF
465	serge	1281
886	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 1066