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

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

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/core/taskman.inc – Rev 4423