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: 996 $
		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
996	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	add esp, 12
		450	popad
		451	iretd
897	serge	452
908	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
		545	mov ecx, 512
		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
861	serge	556	mov edx, [app_tabs]
		557	mov edi, master_tab
164	serge	558	@@:
854	serge	559	call _alloc_page
886	serge	560	test eax, eax
		561	jz .fail
164	serge	562
861	serge	563	or eax, PG_UW
		564	stosd
		565	dec edx
		566	jnz @B
164	serge	567
839	serge	568	mov edi, page_tabs
886	serge	569	mov ecx, [app_tabs]
		570	shl ecx, 10
		571	xor eax, eax
		572	rep stosd
164	serge	573
886	serge	574	mov ecx, [app_pages]
888	serge	575	xor ebx, ebx
164	serge	576	.alloc:
888	serge	577	xor ecx, ecx
		578	call @core_alloc@4
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
		618	xor ecx, ecx
897	serge	619	call @core_alloc@4
		620	test eax, eax
908	serge	621	mov [esp], eax
897	serge	622	jz .fail
		623
		624	mov ecx, 512
		625	lea edi, [eax + OS_BASE]
		626	xor eax, eax
		627	cld
		628	rep stosd
		629
		630	mov ecx, 512
		631	mov esi, _sys_pdbr+(HEAP_BASE shr 20)
		632	rep movsd
		633
908	serge	634	mov esi, [esp]
		635	shr ebx, 22
		636	.new_ptab:
		637	xor ecx, ecx
		638	call @core_alloc@4
		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
		654	xor ecx, ecx
		655	call @core_alloc@4
		656	test eax, eax
		657	jz .fail
		658
		659	lea edi, [eax+OS_BASE]
		660	or eax, PG_UW
		661
		662	mov ebx, [esp]
		663	lea edx, [ebx+PG_SW]
		664	mov [ebx+OS_BASE+(0x7FC00000 shr 20)], eax
		665	mov [ebx+OS_BASE+(page_tabs shr 20)], edx
		666
		667	mov ecx, 1024
		668	xor eax, eax
		669	rep stosd
		670
		671	mov eax, ebx
897	serge	672	.fail:
908	serge	673	mov ebx, [esp+4]
		674	mov esi, [esp+8]
		675	mov edi, [esp+12]
		676
		677	add esp, 16
897	serge	678	ret
		679
		680	align 4
164	serge	681	set_cr3:
465	serge	682
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
888	serge	704	call @core_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]
		762	call @core_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]
		769	call @core_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
886	serge	1051	;mov esi,new_process_loading
		1052	;call sys_msg_board_str
		1053	DEBUGF 1,"%s",new_process_loading
164	serge	1054	.wait_lock:
886	serge	1055	cmp [application_table_status],0
		1056	je .get_lock
164	serge	1057
886	serge	1058	call change_task
		1059	jmp .wait_lock
		1060
164	serge	1061	.get_lock:
886	serge	1062	mov eax, 1
		1063	xchg eax, [application_table_status]
		1064	cmp eax, 0
		1065	jne .wait_lock
164	serge	1066
886	serge	1067	call set_application_table_status
164	serge	1068
886	serge	1069	call get_new_process_place
		1070	test eax, eax
		1071	jz .failed
164	serge	1072
886	serge	1073	mov [slot], eax
164	serge	1074
886	serge	1075	mov esi,[current_slot]
		1076	mov ebx,esi ;ebx=esi - pointer to extended information about current thread
164	serge	1077
886	serge	1078	mov edi, eax
		1079	shl edi,8
		1080	add edi,SLOT_BASE
		1081	mov edx,edi ;edx=edi - pointer to extended infomation about new thread
		1082	mov ecx,256/4
		1083	xor eax, eax
		1084	cld
		1085	rep stosd ;clean extended information about new thread
		1086	mov esi,ebx
		1087	mov edi,edx
		1088	mov ecx,11
		1089	rep movsb ;copy process name
164	serge	1090
886	serge	1091	mov eax,[ebx+APPDATA.heap_base]
		1092	mov [edx+APPDATA.heap_base], eax
164	serge	1093
886	serge	1094	mov ecx,[ebx+APPDATA.heap_top]
		1095	mov [edx+APPDATA.heap_top], ecx
237	serge	1096
886	serge	1097	mov eax,[ebx+APPDATA.mem_size]
		1098	mov [edx+APPDATA.mem_size], eax
237	serge	1099
886	serge	1100	mov ecx,[ebx+APPDATA.dir_table]
		1101	mov [edx+APPDATA.dir_table],ecx ;copy page directory
237	serge	1102
886	serge	1103	lea eax, [app_cmdline]
		1104	stdcall set_app_params ,[slot],eax,dword 0,\
		1105	dword 0,dword 0
237	serge	1106
886	serge	1107	;mov esi,new_process_running
		1108	;call sys_msg_board_str ;output information about succefull startup
		1109	DEBUGF 1,"%s",new_process_running
164	serge	1110
886	serge	1111	mov [application_table_status],0 ;unlock application_table_status mutex
		1112	mov eax,[process_number] ;set result
		1113	ret
164	serge	1114	.failed:
886	serge	1115	mov [application_table_status],0
		1116	mov eax,-1
		1117	ret
164	serge	1118	endp
		1119
276	serge	1120	; param
		1121	; ebx=mutex
		1122
164	serge	1123	align 4
276	serge	1124	wait_mutex:
886	serge	1125	push eax
		1126	push ebx
321	diamond	1127	.do_wait:
886	serge	1128	cmp dword [ebx],0
		1129	je .get_lock
		1130
		1131	call change_task
		1132	jmp .do_wait
164	serge	1133	.get_lock:
886	serge	1134	mov eax, 1
		1135	xchg eax, [ebx]
		1136	test eax, eax
		1137	jnz .do_wait
164	serge	1138
886	serge	1139	pop ebx
		1140	pop eax
		1141	ret
		1142
465	serge	1143
		1144
237	serge	1145	align 4
		1146	proc set_app_params stdcall,slot:dword, params:dword,\
774	Rus	1147	cmd_line:dword, app_path:dword, flags:dword
164	serge	1148
886	serge	1149	locals
		1150	pl0_stack dd ?
		1151	endl
237	serge	1152
864	serge	1153	mov ecx, 1 ;(RING0_STACK_SIZE+512) shr 12
		1154	call @core_alloc@4
839	serge	1155	add eax, OS_BASE
886	serge	1156	mov [pl0_stack], eax
357	serge	1157
886	serge	1158	lea edi, [eax+RING0_STACK_SIZE]
357	serge	1159
886	serge	1160	mov eax, [slot]
		1161	mov ebx, eax
357	serge	1162
886	serge	1163	shl eax, 8
		1164	mov [eax+SLOT_BASE+APPDATA.fpu_state], edi
		1165	mov [eax+SLOT_BASE+APPDATA.fpu_handler], 0
		1166	mov [eax+SLOT_BASE+APPDATA.sse_handler], 0
357	serge	1167
465	serge	1168	;set default io permission map
886	serge	1169	mov [eax+SLOT_BASE+APPDATA.io_map],\
		1170	(tss._io_map_0-OS_BASE+PG_MAP)
		1171	mov [eax+SLOT_BASE+APPDATA.io_map+4],\
		1172	(tss._io_map_1-OS_BASE+PG_MAP)
465	serge	1173
886	serge	1174	mov esi, fpu_data
		1175	mov ecx, 512/4
		1176	rep movsd
237	serge	1177
886	serge	1178	cmp ebx,[TASK_COUNT]
		1179	jle .noinc
		1180	inc dword [TASK_COUNT] ;update number of processes
237	serge	1181	.noinc:
886	serge	1182	shl ebx,8
		1183	lea edx, [ebx+SLOT_BASE+APP_EV_OFFSET]
		1184	mov [SLOT_BASE+APPDATA.fd_ev+ebx],edx
		1185	mov [SLOT_BASE+APPDATA.bk_ev+ebx],edx
354	serge	1186
886	serge	1187	add edx, APP_OBJ_OFFSET-APP_EV_OFFSET
		1188	mov [SLOT_BASE+APPDATA.fd_obj+ebx],edx
		1189	mov [SLOT_BASE+APPDATA.bk_obj+ebx],edx
237	serge	1190
886	serge	1191	mov ecx, [def_cursor]
		1192	mov [SLOT_BASE+APPDATA.cursor+ebx],ecx
		1193	mov eax, [pl0_stack]
		1194	mov [SLOT_BASE+APPDATA.pl0_stack+ebx],eax
		1195	add eax, RING0_STACK_SIZE
		1196	mov [SLOT_BASE+APPDATA.saved_esp0+ebx], eax
281	serge	1197
854	serge	1198	call _alloc_page
839	serge	1199	add eax, OS_BASE
886	serge	1200	mov esi,[current_slot]
		1201	mov esi,[esi+APPDATA.cur_dir]
		1202	mov ecx,0x1000/4
		1203	mov edi,eax
		1204	mov [ebx+SLOT_BASE+APPDATA.cur_dir],eax
		1205	rep movsd
521	diamond	1206
886	serge	1207	shr ebx,3
840	serge	1208	mov dword [CURRENT_TASK+ebx+0x10], 0
237	serge	1209
		1210	.add_command_line:
886	serge	1211	mov edx,[params]
		1212	mov edx,[edx] ;app_cmdline
		1213	test edx,edx
		1214	jz @f ;application doesn't need parameters
281	serge	1215
886	serge	1216	mov eax, edx
		1217	add eax, 256
		1218	jc @f
281	serge	1219
886	serge	1220	cmp eax, [SLOT_BASE+APPDATA.mem_size+ebx*8]
		1221	ja @f
281	serge	1222
886	serge	1223	mov byte [edx], 0 ;force empty string if no cmdline given
		1224	mov eax, [cmd_line]
		1225	test eax, eax
		1226	jz @f
		1227	stdcall strncpy, edx, eax, 256
237	serge	1228	@@:
886	serge	1229	mov edx,[params]
		1230	mov edx, [edx+4] ;app_path
		1231	test edx,edx
		1232	jz @F ;application don't need path of file
		1233	mov eax, edx
		1234	add eax, 1024
		1235	jc @f
		1236	cmp eax, [SLOT_BASE+APPDATA.mem_size+ebx*8]
		1237	ja @f
		1238	stdcall strncpy, edx, [app_path], 1024
237	serge	1239	@@:
886	serge	1240	mov ebx,[slot]
		1241	mov eax,ebx
		1242	shl ebx,5
		1243	lea ecx,[draw_data+ebx] ;ecx - pointer to draw data
465	serge	1244
237	serge	1245	; set window state to 'normal' (non-minimized/maximized/rolled-up) state
886	serge	1246	mov [ebx+window_data+WDATA.fl_wstate], WSTATE_NORMAL
		1247	mov [ebx+window_data+WDATA.fl_redraw], 1
		1248	add ebx,CURRENT_TASK ;ebx - pointer to information about process
		1249	mov [ebx+TASKDATA.wnd_number],al;set window number on screen = process slot
237	serge	1250
886	serge	1251	mov [ebx+TASKDATA.event_mask],dword 1+2+4 ;set default event flags (see 40 function)
237	serge	1252
886	serge	1253	inc dword [process_number]
		1254	mov eax,[process_number]
		1255	mov [ebx+4],eax ;set PID
237	serge	1256
		1257	;set draw data to full screen
		1258
886	serge	1259	mov [ecx+0],dword 0
		1260	mov [ecx+4],dword 0
		1261	mov eax,[Screen_Max_X]
		1262	mov [ecx+8],eax
		1263	mov eax,[Screen_Max_Y]
		1264	mov [ecx+12],eax
237	serge	1265
886	serge	1266	mov ebx, [pl0_stack]
		1267	mov esi,[params]
		1268	lea ecx, [ebx+REG_EIP]
		1269	xor eax, eax
237	serge	1270
886	serge	1271	mov [ebx+REG_RET], dword irq0.return
		1272	mov [ebx+REG_EDI], eax
		1273	mov [ebx+REG_ESI], eax
		1274	mov [ebx+REG_EBP], eax
		1275	mov [ebx+REG_ESP], ecx ;ebx+REG_EIP
		1276	mov [ebx+REG_EBX], eax
		1277	mov [ebx+REG_EDX], eax
		1278	mov [ebx+REG_ECX], eax
		1279	mov [ebx+REG_EAX], eax
237	serge	1280
886	serge	1281	mov eax, [esi+0x08] ;app_eip
		1282	mov [ebx+REG_EIP], eax ;app_entry
928	serge	1283	mov [ebx+REG_CS], dword sel_app_code
886	serge	1284	mov [ebx+REG_EFLAGS], dword EFL_IOPL3+EFL_IF
465	serge	1285
886	serge	1286	mov eax, [esi+0x0C] ;app_esp
		1287	mov [ebx+REG_APP_ESP], eax ;app_stack
928	serge	1288	mov [ebx+REG_SS], dword sel_app_data
237	serge	1289
886	serge	1290	lea ecx, [ebx+REG_RET]
		1291	mov ebx, [slot]
		1292	shl ebx, 5
		1293	mov [ebx*8+SLOT_BASE+APPDATA.saved_esp], ecx
237	serge	1294
886	serge	1295	xor ecx, ecx ; process state - running
237	serge	1296	; set if debuggee
886	serge	1297	test byte [flags], 1
		1298	jz .no_debug
		1299
		1300	inc ecx ; process state - suspended
		1301	mov eax,[CURRENT_TASK]
		1302	mov [SLOT_BASE+ebx*8+APPDATA.debugger_slot],eax
237	serge	1303	.no_debug:
886	serge	1304	mov [CURRENT_TASK+ebx+TASKDATA.state], cl
		1305	DEBUGF 1,"%s",new_process_running
		1306	ret
237	serge	1307	endp
		1308
164	serge	1309	include "debug.inc"

Subversion Repositories Kolibri OS

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