WebSVN – Kolibri OS – Blame – /kernel/branches/gfx_kernel/core/newproce.inc

Rev	Author	Line No.	Line
129	mikedld	1	if ~defined newprocess_inc
		2	newprocess_inc_fix:
		3	newprocess_inc fix newprocess_inc_fix
		4	include "mem.inc"
		5	include "memmanag.inc"
		6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
		7	;;Working with new types of processes.
		8	;;Author: Khalyavin Andrey halyavin@land.ru
		9	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
		10	iglobal
		11	new_process_loading db 'K : New Process - loading',13,10,0
		12	new_process_running db 'K : New Process - done',13,10,0
		13	start_not_enough_memory db 'K : New Process - not enough memory',13,10,0
		14	endg
		15	;-----------------------------------------------------------------------------
		16
		17	find_new_process_place:
		18	;input:
		19	; none
		20	;result:
		21	; eax=[new_process_place]<>0 - ok
		22	; 0 - failed.
		23	;This function find least empty slot.
		24	;It doesn't increase [0x3004]!
		25	mov eax,0x3000+second_base_address
		26	push ebx
		27	mov ebx,[0x3004]
		28	inc ebx
		29	shl ebx,5
		30	add ebx,eax ;ebx - address of process information for (last+1) slot
		31	.newprocessplace:
		32	;eax = address of process information for current slot
		33	cmp eax,ebx
		34	jz .endnewprocessplace ;empty slot after high boundary
		35	add eax,0x20
		36	cmp word [eax+TASKDATA.state],9 ;check process state, 9 means that process slot is empty
		37	jnz .newprocessplace
		38	.endnewprocessplace:
		39	mov ebx,eax
		40	sub eax,0x3000+second_base_address
		41	shr eax,5 ;calculate slot index
		42	cmp eax,256
		43	jge .failed ;it should be <256
		44	mov word [ebx+TASKDATA.state],9 ;set process state to 9 (for slot after hight boundary)
		45	mov [new_process_place],eax ;save process slot
		46	pop ebx
		47	ret
		48	.failed:
		49	xor eax,eax
		50	pop ebx
		51	ret
		52	;-----------------------------------------------------------------------------
		53	safe_sti:
		54	cmp byte [0xe000], 1
		55	jne @f
		56	sti
		57	@@:ret
		58
		59	new_start_application_floppy:
		60	;input:
		61	; eax - pointer to filename
		62	; ebx - parameters to pass
		63	; edx - flags
		64	;result:
		65	; eax - pid of new process
		66	; or 0 if call fails.
		67	mov [appl_path],edi
		68	pushad
		69	mov esi,new_process_loading
		70	call sys_msg_board_str ;write to debug board
		71
		72	;wait application_table_status mutex
		73	.table_status:
		74	cli
		75	cmp [application_table_status],0
		76	jz .stf
		77	sti
		78	call change_task
		79	jmp .table_status
		80	.stf:
		81	call set_application_table_status
		82	;we can change system tables now
		83	push edi
		84	push ebx
		85	push eax
		86	call find_new_process_place ;find empty process slot
		87	sti
		88	test eax,eax
		89	mov ecx, -0x20 ; too many processes
		90	jz .failed
		91
		92	mov edi,eax
		93	shl edi,8
		94	add edi,0x80000
		95	mov ecx,256/4
		96	xor eax,eax
		97	cld
		98	rep stosd ;clean extended information about process
		99
		100	;set new process name
		101	mov [appl_path_size],eax
		102	pop eax
		103	push eax
		104	.find_last_byte:
		105	cmp byte [eax],0
		106	jz .find_last_byte_end
		107	inc eax
		108	inc [appl_path_size]
		109	jmp .find_last_byte
		110	.find_last_byte_end:
		111	add [appl_path_size],24
		112	sub eax,11 ;last 11 bytes = application name
		113	; mov eax,[esp] ;eax - pointer to file name
		114	mov ebx,[new_process_place]
		115	shl ebx,8
		116	add ebx,0x80000 + APPDATA.app_name
		117	mov ecx,11
		118	call memmove
		119
		120	;read header of file
		121	mov eax,[esp]
		122	mov ebx,1 ;index of first block
		123	mov ecx,2 ;number of blocks
		124	mov edx,0x90000 ;temp area
		125	mov esi,12 ;file name length
		126	mov edi,[esp+8]
		127	; cli
		128	call floppy_fileread ;read file from FD
		129	; sti
		130	mov ecx, eax
		131	neg ecx
		132	jnz .cleanfailed
		133	;check MENUET signature
		134	mov ecx, -0x1F ; not Menuet/Kolibri executable
		135	cmp [0x90000],dword 'MENU'
		136	jnz .cleanfailed
		137	cmp [0x90004],word 'ET'
		138	jnz .cleanfailed
		139
		140	call get_app_params ;parse header fields
133	diamond	141	jc .cleanfailed
129	mikedld	142
		143	mov eax,[new_process_place]
		144	inc ecx ; -0x1E = no memory
		145	call create_app_cr3_table ;create page directory for new process
		146	test eax,eax
		147	jz .cleanfailed_mem
		148
		149	call MEM_Get_Linear_Address ;calculate linear address of it
		150
		151	mov ebx,std_application_base_address
		152	mov ecx,[app_mem]
		153	add ecx,4095
		154	shr ecx,12
		155	mov edx,eax
		156	call mem_alloc_specified_region ;allocate memory for application
		157	test eax,eax
		158	mov ecx, -0x1E
		159	jz .cleanfailed_mem1
		160
		161	mov eax,[edx+(std_application_base_address shr 20)]
		162	and eax,not (4096-1) ;eax - physical address of first (for application memory) page table
		163	call MEM_Get_Linear_Address
		164	mov edx,eax
		165
		166	;read file
		167	mov ebx,1
		168	mov esi,12 ;length of file name
		169	.loop1:
		170	;edx = linear address of current page table entry
		171	;ebx = index of current block in file
		172	push edx
		173	mov eax,[edx]
		174	and eax,not (4096-1)
		175	call MEM_Get_Linear_Address
		176	mov edx,eax ;read file block to current page
		177	mov eax,[esp+4] ;restore pointer to file name
		178	mov ecx,8 ;number of blocks read
133	diamond	179	mov ebp,edx ;save buffer address for .endofimage
129	mikedld	180	push ebx
		181	mov edi,[esp+16]
		182	; cli
		183	call floppy_fileread
		184	;ebx=file size
		185	; sti
		186	pop ecx
133	diamond	187	add ecx,8
		188	test eax,eax
		189	jnz .endloop1 ;check io errors
		190	mov eax,[app_i_end]
		191	add eax,511
		192	shr eax,9
		193	cmp ecx,eax
		194	jg .endofimage ;we have loaded whole program
		195	add ebx,511
129	mikedld	196	shr ebx,9
		197	cmp ecx,ebx
		198	jg .endloop1 ;if end of file?
		199	mov ebx,ecx
		200	pop edx
		201	add edx,4
		202	jmp .loop1
		203
133	diamond	204	.endofimage: ;set to zero memory at end of page
		205	mov ecx,[app_i_end]
		206	and ecx,4096-1
		207	jz .endloop1
		208	lea edi,[ebp+ecx]
		209	neg ecx
		210	add ecx,4096
		211	xor eax,eax
		212	cld
		213	rep stosb
129	mikedld	214	.endloop1:
		215	add esp,8+4 ;pop linear address of page table entry and pointer to file name
		216	call new_start_application_fl.add_app_parameters
		217	mov [esp+28],eax
		218	popad
		219	ret
		220
		221	.cleanfailed_mem1:
		222	;there is mem for directory entry, but there is no mem for pages
		223	;so free directory entry
		224	mov eax,[new_process_place]
		225	shl eax,8
		226	mov eax,[0x80000+eax+APPDATA.dir_table]
		227	call MEM_Free_Page
		228	.cleanfailed_mem:
		229	;there is no mem for directory entry, display message.
		230	mov esi,start_not_enough_memory
		231	call sys_msg_board_str
		232	.cleanfailed: ;clean process name
		233	push ecx ; save error code
		234	;can't read file, clean process name.
		235	;this avoid problems with panel application.
		236	mov edi,[new_process_place]
		237	shl edi,8
		238	add edi,0x80000 + APPDATA.app_name
		239	mov ecx,11
		240	mov eax,' '
		241	cld
		242	rep stosb
		243	pop eax
		244	.failed:
		245	;no more slots
		246	add esp,8+4
		247	mov [application_table_status],0
		248	mov [esp+1Ch], eax
		249	popad
		250	sti
		251	ret
		252
		253	;-----------------------------------------------------------------------------
		254	new_start_application_fl:
		255	;input:
		256	; eax - pointer to filename
		257	; ebx - parameters to pass
		258	; edx - flags
		259	;result:
		260	; eax - pid of new process
		261	; or 0 if call fails.
		262	mov [appl_path],edi
		263	mov [appl_path_size],36
		264	pushad
		265	mov esi,new_process_loading
		266	call sys_msg_board_str ;write to debug board
		267
		268	;wait application_table_status mutex
		269	.table_status:
		270	cli
		271	cmp [application_table_status],0
		272	jz .stf
		273	sti
		274	call change_task
		275	jmp .table_status
		276	.stf:
		277	call set_application_table_status
		278	;we can change system tables now
		279	push ebx
		280	push eax
		281	call find_new_process_place ;find empty process slot
		282	call safe_sti
		283	test eax,eax
		284	mov ecx, -0x20 ; too many processes
		285	jz .failed
		286
		287	mov edi,eax
		288	shl edi,8
		289	add edi,0x80000
		290	mov ecx,256/4
		291	xor eax,eax
		292	cld
		293	rep stosd ;clean extended information about process
		294
		295	;set new process name
		296	mov eax,[esp] ;eax - pointer to file name
		297	mov ebx,[new_process_place]
		298	shl ebx,8
		299	add ebx,0x80000 + APPDATA.app_name
		300	mov ecx,11
		301	call memmove
		302
		303	;read header of file
		304	mov ebx,1 ;index of first block
		305	mov ecx,2 ;number of blocks
		306	mov edx,0x90000 ;temp area
		307	mov esi,12 ;file name length
		308	cli
		309	call fileread ;read file from RD
		310	call safe_sti
		311	mov ecx, eax
		312	neg ecx
		313	jnz .cleanfailed
		314	;check MENUET signature
		315	mov ecx, -0x1F ; not Menuet/Kolibri executable
		316	cmp [0x90000],dword 'MENU'
		317	jnz .cleanfailed
		318	cmp [0x90004],word 'ET'
		319	jnz .cleanfailed
		320
		321	call get_app_params ;parse header fields
133	diamond	322	jc .cleanfailed
129	mikedld	323
		324	mov eax,[new_process_place]
		325	inc ecx ; -0x1E = no memory
		326	call create_app_cr3_table ;create page directory for new process
		327	test eax,eax
		328	jz .cleanfailed_mem
		329
		330	call MEM_Get_Linear_Address ;calculate linear address of it
		331
		332	mov ebx,std_application_base_address
		333	mov ecx,[app_mem]
		334	add ecx,4095
		335	shr ecx,12
		336	mov edx,eax
		337	call mem_alloc_specified_region ;allocate memory for application
		338	test eax,eax
		339	mov ecx, -0x1E
		340	jz .cleanfailed_mem1
		341
		342	mov eax,[edx+(std_application_base_address shr 20)]
		343	and eax,not (4096-1) ;eax - physical address of first (for application memory) page table
		344	call MEM_Get_Linear_Address
		345	mov edx,eax
		346
		347	;read file
		348	mov ebx,1
		349	mov esi,12 ;length of file name
		350	.loop1:
		351	;edx = linear address of current page table entry
		352	;ebx = index of current block in file
		353	push edx
		354	mov eax,[edx]
		355	and eax,not (4096-1)
		356	call MEM_Get_Linear_Address
		357	mov edx,eax ;read file block to current page
		358	mov eax,[esp+4] ;restore pointer to file name
		359	mov ecx,8 ;number of blocks read
133	diamond	360	mov ebp,edx ;save buffer address for .endofimage
129	mikedld	361	push ebx
		362	cli
		363	call fileread
		364	;ebx=file size
		365	call safe_sti
		366	pop ecx
133	diamond	367	add ecx,8
		368	test eax,eax
		369	jnz .endloop1 ;check io errors
		370	mov eax,[app_i_end]
		371	add eax,511
		372	shr eax,9
		373	cmp ecx,eax
		374	jg .endofimage ;we have loaded whole program
		375	add ebx,511
129	mikedld	376	shr ebx,9
		377	cmp ecx,ebx
		378	jg .endloop1 ;if end of file?
		379	mov ebx,ecx
		380	pop edx
		381	add edx,4
		382	jmp .loop1
		383
133	diamond	384	.endofimage: ;set to zero memory at end of page
		385	mov ecx,[app_i_end]
		386	and ecx,4096-1
		387	jz .endloop1
		388	lea edi,[ebp+ecx]
		389	neg ecx
		390	add ecx,4096
		391	xor eax,eax
		392	cld
		393	rep stosb
129	mikedld	394	.endloop1:
		395	add esp,8 ;pop linear address of page table entry and pointer to file name
		396	call .add_app_parameters
		397	mov [esp+28],eax
		398	popad
		399	ret
		400
		401	.cleanfailed_mem1:
		402	;there is mem for directory entry, but there is no mem for pages
		403	;so free directory entry
		404	mov eax,[new_process_place]
		405	shl eax,8
		406	mov eax,[0x80000+eax+APPDATA.dir_table]
		407	call MEM_Free_Page
		408	.cleanfailed_mem:
		409	;there is no mem for directory entry, display message.
		410	mov esi,start_not_enough_memory
		411	call sys_msg_board_str
		412	.cleanfailed: ;clean process name
		413	push ecx ; save error code
		414	;can't read file, clean process name.
		415	;this avoid problems with panel application.
		416	mov edi,[new_process_place]
		417	shl edi,8
		418	add edi,0x80000+APPDATA.app_name
		419	mov ecx,11
		420	mov eax,' '
		421	cld
		422	rep stosb
		423	pop eax
		424	.failed:
		425	;no more slots
		426	add esp,8
		427	mov [application_table_status],0
		428	mov [esp+1Ch], eax
		429	popad
		430	call safe_sti
		431	ret
		432
		433	.add_app_parameters:
		434	;input:
		435	; [esp] - pointer to parameters
		436	; [esp+4]-[esp+36] pushad registers.
		437	;result
		438	; eax - pid of new process
		439	; or zero if failed
		440	cli
		441	mov ebx,[new_process_place]
		442	cmp ebx,[0x3004]
		443	jle .noinc
		444	inc dword [0x3004] ;update number of processes
		445	.noinc:
		446
		447	; mov ebx,[new_process_place]
		448	;set 0x8c field of extended information about process
		449	;(size of application memory)
		450	shl ebx,8
		451	mov eax,[app_mem]
		452	mov [second_base_address+0x80000+APPDATA.mem_size+ebx],eax
		453	;set 0x10 field of information about process
		454	;(application base address)
		455	; mov ebx,[new_process_place]
		456	; shl ebx,5
		457	shr ebx,3
		458	mov dword [second_base_address+0x3000+ebx+TASKDATA.mem_start],std_application_base_address
		459
		460	;add command line parameters
		461	.add_command_line:
		462	mov edx,[app_i_param]
		463	test edx,edx
		464	jz .no_command_line ;application don't need parameters
		465	mov eax,[esp+4]
		466	test eax,eax
		467	jz .no_command_line ;no parameters specified
		468	;calculate parameter length
		469	mov esi,eax
		470	xor ecx,ecx
		471	.command_line_len:
		472	cmp byte [esi],0
		473	jz .command_line_len_end
		474	inc esi
		475	inc ecx
		476	cmp ecx,256
		477	jl .command_line_len
		478
		479	.command_line_len_end:
		480	;ecx - parameter length
		481	;edx - address of parameters in new process address space
		482	mov ebx,eax ;ebx - address of parameters in our address space
		483	mov eax,[new_process_place]
		484	call write_process_memory ;copy parameters to new process address space
		485
		486	.no_command_line:
		487	;******************************************************************
		488	mov edx,[app_i_icon]
		489	test edx,edx
		490	jz .no_command_line_1 ;application don't need path of file
		491	mov ebx,[appl_path]
		492	mov ecx,[appl_path_size]
		493	mov eax,[new_process_place]
		494	call write_process_memory ;copy path of file to new process address space
		495	.no_command_line_1:
		496	;******************************************************************
		497	mov ebx,[new_process_place]
		498	mov eax,ebx
		499	shl ebx,5
		500	add ebx,0x3000 ;ebx - pointer to information about process
		501	mov [ebx+TASKDATA.wnd_number],al ;set window number on screen = process slot
		502
		503	mov [ebx+TASKDATA.event_mask],dword 1+2+4 ;set default event flags (see 40 function)
		504
		505	inc dword [process_number]
		506	mov eax,[process_number]
		507	mov [ebx+TASKDATA.pid],eax ;set PID
		508
		509	mov ecx,ebx
		510	add ecx,draw_data-0x3000 ;ecx - pointer to draw data
		511	;set draw data to full screen
		512	mov [ecx+RECT.left],dword 0
		513	mov [ecx+RECT.top],dword 0
		514	mov eax,[0xfe00]
		515	mov [ecx+RECT.right],eax
		516	mov eax,[0xfe04]
		517	mov [ecx+RECT.bottom],eax
		518	;set window state to 'normal' (non-minimized/maximized/rolled-up) state
		519	mov [ecx+WDATA.fl_wstate],WSTATE_NORMAL
		520	;set cr3 register in TSS of application
		521	mov ecx,[new_process_place]
		522	shl ecx,8
		523	mov eax,[0x80000+APPDATA.dir_table+ecx]
		524	add eax,8+16 ;add flags
		525	mov [l.cr3],eax
		526
		527	mov eax,[app_start]
		528	mov [l.eip],eax ;set eip in TSS
		529	mov eax,[app_esp]
		530	mov [l.esp],eax ;set stack in TSS
		531
		532	;gdt
		533	;mov ebx,[new_process_place]
		534	;shl ebx,3
		535	mov ax,app_code ;ax - selector of code segment
		536	;add ax,bx
		537	mov [l.cs],ax
		538	mov ax,app_data
		539	;add ax,bx ;ax - selector of data segment
		540	mov [l.ss],ax
		541	mov [l.ds],ax
		542	mov [l.es],ax
		543	mov [l.fs],ax
		544	mov ax,graph_data ;ax - selector of graphic segment
		545	mov [l.gs],ax
		546	mov [l.io],word 128
		547	mov [l.eflags],dword 0x11202
		548	mov [l.ss0],os_data
		549	mov ebx,[new_process_place]
		550	shl ebx,12
		551	add ebx,sysint_stack_data+4096
		552	mov [l.esp0],ebx
		553
		554	;copy tss to it place
		555	mov eax,tss_sceleton
		556	mov ebx,[new_process_place]
		557	imul ebx,tss_step
		558	add ebx,tss_data ;ebx - address of application TSS
		559	mov ecx,120
		560	call memmove
		561
		562	;Add IO access table - bit array of permitted ports
		563	or eax,-1
		564	mov edi,[new_process_place]
		565	imul edi,tss_step
		566	add edi,tss_data+128
		567	mov ecx,2048
		568	cld
		569	rep stosd ;full access to 2048*8=16384 ports
		570
		571	mov ecx,ebx ;ecx - address of application TSS
		572	mov edi,[new_process_place]
		573	shl edi,3
		574	;set TSS descriptor
		575	mov [edi+gdts+tss0+0],word tss_step ;limit (size)
		576	mov [edi+gdts+tss0+2],cx ;part of offset
		577	mov eax,ecx
		578	shr eax,16
		579	mov [edi+gdts+tss0+4],al ;part of offset
		580	mov [edi+gdts+tss0+7],ah ;part of offset
		581	mov [edi+gdts+tss0+5],word 01010000b*256+11101001b ;system flags
		582
		583
		584	;flush keyboard and buttons queue
		585	mov [0xf400],byte 0
		586	mov [0xf500],byte 0
		587
		588	mov edi,[new_process_place]
		589	shl edi,5
		590	add edi,window_data
		591	mov ebx,[new_process_place]
		592	movzx esi,word [0xC000+ebx*2]
		593	lea esi,[0xC400+esi*2]
		594	call windowactivate ;gui initialization
		595
		596	mov ebx,[new_process_place]
		597	shl ebx,5
		598	; set if debuggee
		599	test byte [esp+28], 1
		600	jz .no_debug
		601	mov [0x3000+ebx+TASKDATA.state], 1 ; set process state - suspended
		602	mov eax, [0x3000]
		603	mov [0x80000+ebx*8+APPDATA.debugger_slot], eax ;set debugger PID - current
		604	jmp .debug
		605	.no_debug:
		606	mov [0x3000+ebx+TASKDATA.state], 0 ; set process state - running
		607	.debug:
		608
		609	mov esi,new_process_running
		610	call sys_msg_board_str ;output information about succefull startup
		611
		612	; add esp,4 ;pop pointer to parameters
		613	; popad
		614	mov eax,[process_number] ;set result
		615	mov [application_table_status],0 ;unlock application_table_status mutex
		616	call safe_sti
		617	ret 4
		618	;-----------------------------------------------------------------------------
		619	new_sys_threads:
		620	;eax=1 - create thread
		621	; ebx=thread start
		622	; ecx=thread stack value
		623	;result:
		624	; eax=pid
		625	xor edx,edx ; flags=0
		626	pushad
		627
		628	cmp eax,1
		629	jnz .ret ;other subfunctions
		630	mov esi,new_process_loading
		631	call sys_msg_board_str
		632	;lock application_table_status mutex
		633	.table_status:
		634	cli
		635	cmp [application_table_status],0
		636	je .stf
		637	sti
		638	call change_task
		639	jmp .table_status
		640	.stf:
		641	call set_application_table_status
		642	;find free process slot
		643
		644	call find_new_process_place
		645	test eax,eax
		646	jz .failed
		647
		648	;set parameters for thread
		649	xor eax,eax
		650	mov [app_i_param],eax
		651	mov [app_i_icon],eax
		652	mov [app_start],ebx
		653	mov [app_esp],ecx
		654
		655	mov esi,[0x3000]
		656	shl esi,8
		657	add esi,0x80000+APPDATA.app_name
		658	mov ebx,esi ;ebx=esi - pointer to extended information about current thread
		659
		660	mov edi,[new_process_place]
		661	shl edi,8
		662	add edi,0x80000
		663	lea edx, [edi+APPDATA.app_name] ;edx=edi - pointer to extended infomation about new thread
		664	mov ecx,256/4
		665	rep stosd ;clean extended information about new thread
		666	mov edi,edx
		667	mov ecx,11
		668	rep movsb ;copy process name
		669	mov eax,[ebx+APPDATA.mem_size]
		670	mov [app_mem],eax ;set memory size
		671	mov eax,[ebx+APPDATA.dir_table]
		672	mov dword [edx-APPDATA.app_name+APPDATA.dir_table],eax ;copy page directory
		673	; mov eax,[new_process_place]
		674	; mov ebx,[0x3000]
		675	; call addreference_app_cr3_table
		676
		677	push 0 ;no parameters
		678	call new_start_application_fl.add_app_parameters ;start thread
		679	mov [esp+28],eax
		680	popad
		681	ret
		682
		683	.failed:
		684	sti
		685	popad
		686	mov eax,-1
		687	ret
		688	.ret:
		689	popad
		690	ret
		691	;-----------------------------------------------------------------------------
		692	new_mem_resize:
		693	;input:
		694	; ebx - new size
		695	;result:
		696	; [esp+36]:=0 - normal
		697	; [esp+36]:=1 - error
		698	;This function set new application memory size.
		699	mov esi,ebx ;save new size
		700	add ebx,4095
		701	and ebx,not (4096-1) ;round up size
		702	mov ecx,[0x3000]
		703	shl ecx,8
		704	mov edx,[0x80000 + APPDATA.mem_size +ecx]
		705	add edx,4095
		706	and edx,not (4096-1) ;old size
		707	mov eax,[0x80000 + APPDATA.dir_table+ecx]
		708	call MEM_Get_Linear_Address
		709	;eax - linear address of page directory
		710	call MEM_Heap_Lock ;guarantee that two threads willn't
		711	;change memory size simultaneously
		712	cmp ebx,edx
		713	; mov esi,ebx ;save new size
		714	jg .expand
		715
		716	.free:
		717	sub edx,ebx
		718	jz .unlock ;do nothing
		719	mov ecx,edx
		720	shr ecx,12
		721	add ebx,std_application_base_address
		722	call mem_free_specified_region ;free unnecessary pages
		723	jmp .unlock
		724
		725	.expand:
		726	sub ebx,edx
		727	mov ecx,ebx
		728	shr ecx,12
		729	mov ebx,edx
		730	add ebx,std_application_base_address
		731	call mem_alloc_specified_region ;alloc necessary pages
		732	test eax,eax
		733	jz .failed ;not enough memory
		734
		735	.unlock:
		736	mov ebx,esi
		737	mov eax,[0x3000]
		738	shl eax,8
		739	mov [eax+0x80000 + APPDATA.mem_size],ebx ;write new memory size
		740	;search threads and update
		741	;application memory size infomation
		742	mov ecx,[eax+0x80000 + APPDATA.dir_table]
		743	mov eax,2
		744
		745	.search_threads:
		746	;eax = current slot
		747	;ebx = new memory size
		748	;ecx = page directory
		749	cmp eax,[0x3004]
		750	jg .search_threads_end
		751	mov edx,eax
		752	shl edx,5
		753	cmp word [0x3000+edx+TASKDATA.state],9 ;if slot empty?
		754	jz .search_threads_next
		755	shl edx,3
		756	cmp [edx+0x80000+APPDATA.dir_table],ecx ;if it is our thread?
		757	jnz .search_threads_next
		758	mov [edx+0x80000+APPDATA.mem_size],ebx ;update memory size
		759	.search_threads_next:
		760	inc eax
		761	jmp .search_threads
		762	.search_threads_end:
		763
		764	call MEM_Heap_UnLock
		765	mov dword [esp+36],0
		766	ret
		767
		768	.failed:
		769	call MEM_Heap_UnLock
		770	mov dword [esp+36],1
		771	ret
		772	;-----------------------------------------------------------------------------
		773	pid_to_slot:
		774	;Input:
		775	; eax - pid of process
		776	;Output:
		777	; eax - slot of process or 0 if process don't exists
		778	;Search process by PID.
		779	push ebx
		780	push ecx
		781	mov ebx,[0x3004]
		782	shl ebx,5
		783	mov ecx,2*32
		784
		785	.loop:
		786	;ecx=offset of current process info entry
		787	;ebx=maximum permitted offset
		788	cmp byte [second_base_address+0x3000+ecx+TASKDATA.state],9
		789	jz .endloop ;skip empty slots
		790	cmp [second_base_address+0x3000+ecx+TASKDATA.pid],eax ;check PID
		791	jz .pid_found
		792	.endloop:
		793	add ecx,32
		794	cmp ecx,ebx
		795	jle .loop
		796
		797	pop ecx
		798	pop ebx
		799	xor eax,eax
		800	ret
		801
		802	.pid_found:
		803	shr ecx,5
		804	mov eax,ecx ;convert offset to index of slot
		805	pop ecx
		806	pop ebx
		807	ret
		808	;-----------------------------------------------------------------------------
		809	is_new_process:
		810	;Input:
		811	; eax - process slot
		812	;Output:
		813	; eax=1 - it is new process
		814	; eax=0 - it is old process
		815	; shl eax,5
		816	; mov eax,[second_base_address+0x3000+eax+0x10]
		817	; cmp eax,std_application_base_address ;check base address of application
		818	; jz .new_process
		819	; xor eax,eax
		820	; ret
		821
		822	;.new_process:
		823	mov eax,1
		824	ret
		825	;-----------------------------------------------------------------------------
		826	write_process_memory:
		827	;Input:
		828	; eax - process slot
		829	; ebx - buffer address
		830	; ecx - buffer size
		831	; edx - start address in other process
		832	;Output:
		833	; eax - number of bytes written
		834	pushad
		835	shl eax,8
		836	mov eax,[0x80000+eax+APPDATA.dir_table]
		837	call MEM_Get_Linear_Address
		838	mov ebp,eax
		839	;ebp=linear address of page directory of other process.
		840	add edx,std_application_base_address ;convert to linear address
		841	test ecx,ecx
		842	jle .ret
		843
		844	.write_loop:
		845	;ebx = current buffer address
		846	;ecx>0 = current size
		847	;edx = current address in other process
		848	;ebp = linear address of page directory
		849
		850	call MEM_Heap_Lock ;cli
		851	mov esi,edx
		852	shr esi,22
		853	mov eax,[ebp+4*esi] ;find page directory entry
		854	and eax,not (4096-1) ;clear flags
		855	test eax,eax
		856	jz .page_not_found
		857	call MEM_Get_Linear_Address ;calculate linear address of page table
		858	test eax,eax
		859	jz .page_not_found
		860	mov esi,edx
		861	shr esi,12
		862	and esi,1023
		863	mov eax,[eax+4*esi] ;find page table entry
		864	and eax,not (4096-1)
		865	test eax,eax
		866	jz .page_not_found
		867	call MEM_Get_Linear_Address ;calculate linear address of page
		868	test eax,eax
		869	jz .page_not_found
		870	mov edi,eax
		871	call MEM_Add_Reference_Linear;guarantee that page willn't disappear
		872	call MEM_Heap_UnLock ;sti
		873
		874	mov esi,edx
		875	and esi,4095
		876	add edi,esi ;add offset in page
		877	;edi = linear address corresponding edx in other process
		878	sub esi,4096
		879	neg esi ;esi - number of remaining bytes in page
		880	cmp esi,ecx
		881	jl .min_ecx
		882	mov esi,ecx
		883	.min_ecx: ;esi=min(ecx,esi) - number of bytes to write
		884	sub ecx,esi
		885	push ecx
		886	mov ecx,esi ;ecx - number of bytes to write
		887	mov esi,ebx ;esi - source, edi - destination
		888	add edx,ecx ;move pointer in address space of other process
		889	push edi
		890
		891	;move ecx bytes
		892	test ecx,3
		893	jnz .not_aligned
		894	shr ecx,2
		895	rep movsd
		896	jmp .next_iter
		897	.not_aligned:
		898	rep movsb
		899	.next_iter:
		900
		901	pop eax
		902	and eax,not (4096-1) ;eax - linear address of current page
		903	call MEM_Free_Page_Linear ;free reference
		904	mov ebx,esi ;new pointer to buffer - movsb automaticaly advance it.
		905	pop ecx ;restore number of remaining bytes
		906	test ecx,ecx
		907	jnz .write_loop
		908	.ret:
		909	popad
		910	mov eax,ecx
		911	ret
		912
		913	.page_not_found:
		914	call MEM_Heap_UnLock ;error has appeared in critical region
		915	sub ecx,[esp+24] ;[esp+24]<-->ecx
		916	neg ecx ;ecx=number_of_written_bytes
		917	mov [esp+28],ecx ;[esp+28]<-->eax
		918	popad
		919	ret
		920	;-----------------------------------------------------------------------------
		921	syscall_test:
		922	;for testing memory manager from applications.
		923	mov edx,ecx
		924	mov ecx,ebx
		925	call trans_address
		926	mov ebx,eax
		927	mov eax,[0x3000]
		928	call read_process_memory
		929	ret
		930	;-----------------------------------------------------------------------------
		931	read_process_memory:
		932	;Input:
		933	; eax - process slot
		934	; ebx - buffer address
		935	; ecx - buffer size
		936	; edx - start address in other process
		937	;Output:
		938	; eax - number of bytes read.
		939	pushad
		940	shl eax,8
		941	mov eax,[0x80000+eax+APPDATA.dir_table]
		942	call MEM_Get_Linear_Address
		943	mov ebp,eax
		944	add edx,std_application_base_address
		945	.read_loop:
		946	;ebx = current buffer address
		947	;ecx>0 = current size
		948	;edx = current address in other process
		949	;ebp = linear address of page directory
		950
		951	call MEM_Heap_Lock ;cli
		952	mov esi,edx
		953	shr esi,22
		954	mov eax,[ebp+4*esi] ;find page directory entry
		955	and eax,not (4096-1)
		956	test eax,eax
		957	jz .page_not_found
		958	call MEM_Get_Linear_Address
		959	test eax,eax
		960	jz .page_not_found
		961	mov esi,edx
		962	shr esi,12
		963	and esi,1023
		964	mov eax,[eax+4*esi] ;find page table entry
		965	and eax,not (4096-1)
		966	test eax,eax
		967	jz .page_not_found
		968	call MEM_Get_Linear_Address ;calculate linear address of page
		969	test eax,eax
		970	jz .page_not_found
		971	mov esi,eax
		972	call MEM_Add_Reference_Linear;guarantee that page willn't disappear
		973	call MEM_Heap_UnLock ;sti
		974
		975	mov edi,edx
		976	and edi,4095
		977	add esi,edi ;add offset in page
		978	;esi = linear address corresponding edx in other process
		979	sub edi,4096
		980	neg edi
		981
		982	;edi=min(edi,ecx) - number of bytes to copy
		983	cmp edi,ecx
		984	jl .min_ecx
		985	mov edi,ecx
		986	.min_ecx:
		987
		988	sub ecx,edi ;update size of remaining bytes
		989	add edx,edi ;update current pointer in other address space.
		990	push ecx
		991	mov ecx,edi ;ecx - number of bytes to read
		992	mov edi,ebx ;esi - source, edi - destination
		993	push esi
		994	;move ecx bytes
		995	test ecx,3
		996	jnz .not_aligned
		997	shr ecx,2
		998	rep movsd
		999	jmp .next_iter
		1000	.not_aligned:
		1001	rep movsb
		1002	.next_iter:
		1003	pop eax
		1004	and eax,not (4096-1) ;eax - linear address of current page
		1005	call MEM_Free_Page_Linear ;free reference
		1006	mov ebx,edi ;new pointer to buffer - movsb automaticaly advance it.
		1007	pop ecx ;restore number of remaining bytes
		1008	test ecx,ecx
		1009	jnz .read_loop
		1010
		1011	popad
		1012	mov eax,ecx
		1013	ret
		1014
		1015	.page_not_found:
		1016	call MEM_Heap_UnLock ;error has appeared in critical region
		1017	sub ecx,[esp+24] ;[esp+24]<-->ecx
		1018	neg ecx ;ecx=number_of_read_bytes
		1019	mov [esp+28],ecx ;[esp+28]<-->eax
		1020	popad
		1021	ret
		1022	;-----------------------------------------------------------------------------
		1023	check_region:
		1024	;input:
		1025	; ebx - start of buffer
		1026	; ecx - size of buffer
		1027	;result:
		1028	; eax = 1 region lays in app memory
		1029	; eax = 0 region don't lays in app memory
		1030	mov eax,[0x3000]
		1031	jmp check_process_region
		1032	;-----------------------------------------------------------------------------
		1033	check_process_region:
		1034	;input:
		1035	; eax - slot
		1036	; ebx - start of buffer
		1037	; ecx - size of buffer
		1038	;result:
		1039	; eax = 1 region lays in app memory
		1040	; eax = 0 region don't lays in app memory
		1041	test ecx,ecx
		1042	jle .ok
		1043	shl eax,5
		1044	cmp word [0x3000+eax+TASKDATA.state],0
		1045	jnz .failed
		1046	shl eax,3
		1047	mov eax,[0x80000+eax+APPDATA.dir_table]
		1048	test eax,eax
		1049	jz .failed
		1050	call MEM_Get_Linear_Address
		1051	push ebx
		1052	push ecx
		1053	push edx
		1054	mov edx,ebx
		1055	and edx,not (4096-1)
		1056	sub ebx,edx
		1057	add ecx,ebx
		1058	mov ebx,edx
		1059	add ecx,(4096-1)
		1060	and ecx,not (4096-1)
		1061	.loop:
		1062	;eax - linear address of page directory
		1063	;ebx - current page
		1064	;ecx - current size
		1065	mov edx,ebx
		1066	shr edx,22
		1067	mov edx,[eax+4*edx]
		1068	and edx,not (4096-1)
		1069	test edx,edx
		1070	jz .failed1
		1071	push eax
		1072	mov eax,edx
		1073	call MEM_Get_Linear_Address
		1074	mov edx,ebx
		1075	shr edx,12
		1076	and edx,(1024-1)
		1077	mov eax,[eax+4*edx]
		1078	and eax,not (4096-1)
		1079	test eax,eax
		1080	pop eax
		1081	jz .failed1
		1082	add ebx,4096
		1083	sub ecx,4096
		1084	jg .loop
		1085	pop edx
		1086	pop ecx
		1087	pop ebx
		1088	.ok:
		1089	mov eax,1
		1090	ret
		1091
		1092	.failed1:
		1093	pop edx
		1094	pop ecx
		1095	pop ebx
		1096	.failed:
		1097	xor eax,eax
		1098	ret
		1099	;-----------------------------------------------------------------------------
		1100	new_sys_ipc:
		1101	;input:
		1102	; eax=1 - set ipc buffer area
		1103	; ebx=address of buffer
		1104	; ecx=size of buffer
		1105	; eax=2 - send message
		1106	; ebx=PID
		1107	; ecx=address of message
		1108	; edx=size of message
		1109	cmp eax,1
		1110	jnz .no_ipc_def
		1111	;set ipc buffer area
		1112	mov edi,[0x3000]
		1113	shl edi,8
		1114	add edi,0x80000
		1115	cli
		1116	mov [edi+APPDATA.ipc_start],ebx ;set fields in extended information area
		1117	mov [edi+APPDATA.ipc_size],ecx
		1118	sti
		1119	mov [esp+36],dword 0 ;success
		1120	ret
		1121
		1122	.no_ipc_def:
		1123	cmp eax,2
		1124	jnz .no_ipc_send
		1125	;send message
		1126	cli
		1127	;obtain slot from PID
		1128	mov eax,ebx
		1129	call pid_to_slot
		1130	test eax,eax
		1131	jz .no_pid
		1132	mov ebp,eax
		1133	;ebp = slot of other process
		1134	shl eax,8
		1135	mov edi,[eax+0x80000+APPDATA.ipc_start] ;is ipc area defined?
		1136	test edi,edi
		1137	jz .no_ipc_area
		1138	mov esi,[eax+0x80000+APPDATA.ipc_size] ;esi - size of buffer
		1139	push dword -1 ;temp variable for read_process_memory
		1140	mov ebx,esp
		1141	push ecx
		1142	push edx
		1143	mov ecx,4 ;read 4 bytes
		1144	mov eax,ebp
		1145	mov edx,edi ;from beginning of buffer.
		1146	call read_process_memory
		1147	mov eax,[esp+8]
		1148	test eax,eax
		1149	jnz .ipc_blocked ;if dword [buffer]<>0 - ipc blocked now
		1150	add edx,4 ;move to next 4 bytes
		1151	mov eax,ebp
		1152	call read_process_memory ;read size of occupied space in buffer
		1153	sub esi,8
		1154	sub esi,[esp]
		1155	sub esi,[esp+8] ;esi=(buffer size)-(occupied size)-(message size)-(header of message size)
		1156	js .buffer_overflow ;esi<0 - not enough memory in buffer
		1157	mov esi,[esp+8] ;previous offset
		1158	add dword [esp+8],8
		1159	mov edi,[esp]
		1160	add [esp+8],edi ;add (size of message)+(size of header of message) to [buffer+4]
		1161	mov eax,ebp
		1162	call write_process_memory
		1163	add edx,esi
		1164	sub edx,4 ;move to beginning of place for our message
		1165	mov eax,[second_base_address+0x3010]
		1166	mov eax,[eax+TASKDATA.pid] ;eax - our PID
		1167	mov [esp+8],eax
		1168	mov eax,ebp
		1169	call write_process_memory ;write PID
		1170	mov ebx,esp ;address of size of message
		1171	mov eax,ebp
		1172	add edx,4
		1173	call write_process_memory ;write size of message
		1174	add edx,4
		1175	pop ecx ;ecx - size of message
		1176	pop eax
		1177	call trans_address
		1178	mov ebx,eax ;ebx - linear address of message
		1179	add esp,4 ;pop temporary variable
		1180	mov eax,ebp
		1181	call write_process_memory ;write message
		1182	sti
		1183	;awake other process
		1184	shl ebp,8
		1185	mov eax,ebp
		1186	or [eax+0x80000+APPDATA.event_mask],dword 0x40
		1187
		1188	cmp dword [check_idle_semaphore],20
		1189	jge .ipc_no_cis
		1190	mov dword [check_idle_semaphore],5
		1191	.ipc_no_cis:
		1192	mov dword [esp+36],0
		1193	ret
		1194	.no_ipc_send:
		1195	mov dword [esp+36],-1
		1196	ret
		1197	.no_pid:
		1198	sti
		1199	mov dword [esp+36],4
		1200	ret
		1201	.no_ipc_area:
		1202	sti
		1203	mov dword [esp+36],1
		1204	ret
		1205	.ipc_blocked:
		1206	sti
		1207	add esp,12
		1208	mov dword [esp+36],2
		1209	ret
		1210	.buffer_overflow:
		1211	sti
		1212	add esp,12
		1213	mov dword [esp+36],3
		1214	ret
		1215	;-----------------------------------------------------------------------------
		1216	trans_address:
		1217	;Input
		1218	; eax - application address
		1219	;Output
		1220	; eax - linear address for kernel
		1221	add eax,std_application_base_address
		1222	ret
		1223	;-----------------------------------------------------------------------------
		1224	new_start_application_hd:
		1225	;eax - file name (kernel address)
		1226	;ebx - file name length
		1227	;ecx - work area (kernel address)
		1228	;edx - flags
		1229	;ebp - parameters
		1230	mov [appl_path],edi
		1231	pushad
		1232
		1233	mov esi,new_process_loading
		1234	call sys_msg_board_str ;write message to message board
		1235
		1236	;lock application_table_status mutex
		1237	.table_status:
		1238	cli
		1239	cmp [application_table_status],0
		1240	jz .stf
		1241	sti
		1242	call change_task
		1243	jmp .table_status
		1244	.stf:
		1245	call set_application_table_status
		1246
		1247	push ebp
		1248	push ebx
		1249	push eax
		1250	push ecx
		1251	call find_new_process_place ;find new process slot
		1252	sti
		1253	test eax,eax
		1254	mov ecx, -0x20 ; too many processes
		1255	jz .failed
		1256
		1257	;write application name
		1258	xor eax,eax
		1259	mov [appl_path_size],eax
		1260	mov eax,[esp+4]
		1261	.find_last_byte:
		1262	cmp byte [eax],0
		1263	jz .find_last_byte_end
		1264	inc eax
		1265	inc [appl_path_size]
		1266	jmp .find_last_byte
		1267	.find_last_byte_end:
		1268	add [appl_path_size],24
		1269	lea esi,[eax-11] ;last 11 bytes = application name
		1270	mov edi,[new_process_place]
		1271	shl edi,8
		1272	add edi,0x80000+APPDATA.app_name
		1273	mov ecx,11
		1274	cld
		1275	rep movsb ;copy name to extended information about process
		1276
		1277	;read header
		1278	mov eax,[esp+4] ;file name
		1279	mov esi,[esp] ;work area
		1280	mov ecx,1 ;read from first block
		1281	mov edx,1 ;read 1 block
		1282	call read_hd_file
		1283	mov ecx, eax
		1284	neg ecx
		1285	jnz .cleanfailed
		1286
		1287	pop esi
		1288	push esi
		1289	;check menuet signature
		1290	mov ecx, -0x1F ; not Menuet/Kolibri executable
		1291	cmp [esi+1024+0],dword 'MENU' ;read_hd_file function write file to +1024 offset
		1292	jnz .cleanfailed
		1293	cmp [esi+1024+4],word 'ET'
		1294	jnz .cleanfailed
		1295	add esi,1024
		1296	mov edi,0x90000
		1297	mov ecx,512/4
		1298	cld
		1299	rep movsd ;copy first block to 0x90000 address for get_app_params function
		1300	call get_app_params
		1301	mov ecx, -0x1F ; not Menuet/Kolibri executable
133	diamond	1302	jc .cleanfailed
129	mikedld	1303
		1304	mov eax,[new_process_place]
		1305	inc ecx ; -0x1E = no memory
		1306	call create_app_cr3_table ;create page directory
		1307	test eax,eax
		1308	jz .cleanfailed_mem
		1309
		1310	call MEM_Get_Linear_Address
		1311
		1312	mov ebx,std_application_base_address
		1313	mov ecx,[app_mem]
		1314	add ecx,4096-1
		1315	shr ecx,12
		1316	mov edx,eax ;edx - linear address of page directory
		1317	call mem_alloc_specified_region ;allocate memory for application
		1318	mov ecx, -0x1E ; no memory
		1319	test eax,eax
		1320	jz .cleanfailed_mem1
		1321
		1322	add edx,(std_application_base_address shr 20)
		1323	mov eax,[edx]
		1324	and eax,not (4096-1)
		1325	call MEM_Get_Linear_Address
		1326	push edx ;save pointer to first page table
		1327	mov edx,eax
		1328	;read file
		1329	mov ecx,1
		1330	xor ebp,ebp
		1331	.loop1:
		1332	;[esp] - pointer to current page directory entry
		1333	;edx - pointer to current page table
		1334	;ebp - offset in page
		1335	;ecx - current cluster
		1336	push edx
		1337	mov eax,[esp+12] ;file name
		1338	mov ebx,[esp+16] ;file name length
		1339	mov esi,[esp+8] ;work area
		1340	mov edx,1 ;number of blocks to read
		1341	push ecx
		1342	push ebp
		1343	cli
		1344	call read_hd_file
		1345	sti
		1346	pop ebp
		1347	test eax,eax
		1348	jnz .endloop1 ;check io errors
		1349
		1350	mov esi,[esp+8+4] ;work area
		1351	add esi,1024
		1352	mov eax,[esp+4] ;current page table
		1353	mov eax,[eax]
		1354	and eax,not (4096-1)
		1355	call MEM_Get_Linear_Address;calculate linear page address
		1356	lea edi,[eax+ebp] ;add page offset
		1357	mov ecx,512/4
		1358	cld
		1359	rep movsd ;copy data
		1360
		1361	pop ecx
		1362	inc ecx ;next block
		1363	mov eax,[app_i_end] ;todo: precalculate ([app_i_end]+4095)/4096
		1364	add eax,512-1
		1365	shr eax,9 ;calculate application image size
		1366	cmp ecx,eax
		1367	jg .endloop11
		1368	pop edx
		1369	add ebp,512 ;new offset
		1370	test ebp,4096
		1371	jz .loop1
		1372	xor ebp,ebp
		1373	add edx,4 ;go to next page
		1374	test edx,(4096-1)
		1375	jnz .loop1
		1376	add dword [esp],4 ;go to next directory entry
		1377	mov eax,[esp]
		1378	mov eax,[eax]
		1379	and eax,not (4096-1)
		1380	call MEM_Get_Linear_Address
		1381	mov edx,eax
		1382	jmp .loop1
		1383	.endloop1:
		1384	add esp,4 ;pop ecx
		1385	.endloop11:
		1386	add esp,4+4 ;pop edx, pop edx
		1387
		1388	;add_app_parameters
		1389	add esp,12 ;now pointer to parameters is on the top of the stack
		1390	call new_start_application_fl.add_app_parameters ;start process
		1391	mov [esp+28],eax
		1392	popad
		1393	ret
		1394
		1395	.cleanfailed_mem1:
		1396	;there is mem for directory entry, but there is no mem for pages
		1397	;so free directory entry
		1398	mov eax,[new_process_place]
		1399	shl eax,8
		1400	mov eax,[0x80000+eax+APPDATA.dir_table]
		1401	call MEM_Free_Page
		1402	.cleanfailed_mem:
		1403	;there is no mem for directory entry, display message.
		1404	mov esi,start_not_enough_memory
		1405	call sys_msg_board_str
		1406	.cleanfailed: ;clean process name
		1407	push ecx
		1408	;can't read file, clean process name.
		1409	;this avoid problems with panel application.
		1410	mov edi,[new_process_place]
		1411	shl edi,8
		1412	add edi,0x80000+APPDATA.app_name
		1413	mov ecx,11
		1414	mov eax,' '
		1415	cld
		1416	rep stosb
		1417	pop eax
		1418	.failed:
		1419	;no more slots
		1420	add esp,16
		1421	mov [esp+1Ch], eax
		1422	popad
		1423	mov [application_table_status],0
		1424	sti
		1425	ret
		1426	end if
		1427
		1428	; \begin{diamond}
		1429	include 'debug.inc'
		1430
		1431	fs_execute:
		1432	; ebx - cmdline
		1433	; edx - flags
		1434	; ebp - full filename
		1435	; [esp+4] = procedure DoRead, [esp+8] = filesize & [esp+12]... - arguments for it
		1436	pushad
		1437	; check filename length - with terminating NULL must be no more than 1024 symbols
		1438	mov edi, ebp
		1439	mov ecx, 1024
		1440	xor eax, eax
		1441	repnz scasb
		1442	jz @f
		1443	popad
		1444	mov eax, -ERROR_FILE_NOT_FOUND
		1445	ret
		1446	@@:
		1447
		1448	mov esi, new_process_loading
		1449	call sys_msg_board_str ; write message to message board
		1450
		1451	; lock application_table_status mutex
		1452	.table_status:
		1453	cli
		1454	cmp [application_table_status], 0
		1455	jz .stf
		1456	sti
		1457	call change_task
		1458	jmp .table_status
		1459	.stf:
		1460	call set_application_table_status
		1461	push ebx ; save command line pointer for add_app_parameters
		1462
		1463	call find_new_process_place ; find new process slot
		1464	call safe_sti
		1465	test eax, eax
		1466	mov ecx, -0x20 ; too many processes
		1467	jz .failed
		1468
		1469	; write application name
		1470	push edi
		1471	mov ecx, edi
		1472	sub ecx, ebp
		1473	mov [appl_path], ebp
		1474	mov [appl_path_size], ecx
		1475	dec edi
		1476	std
		1477	mov al, '/'
		1478	repnz scasb
		1479	cld
		1480	jnz @f
		1481	inc edi
		1482	@@:
		1483	inc edi
		1484	; now edi points to name without path
		1485	mov esi, edi
		1486	mov ecx, 8 ; 8 chars for name
		1487	mov edi, [new_process_place]
		1488	shl edi, cl
		1489	add edi, 0x80000+APPDATA.app_name
		1490	.copy_process_name_loop:
		1491	lodsb
		1492	cmp al, '.'
		1493	jz .copy_process_name_done
		1494	test al, al
		1495	jz .copy_process_name_done
		1496	stosb
		1497	loop .copy_process_name_loop
		1498	.copy_process_name_done:
		1499	mov al, ' '
		1500	rep stosb
		1501	pop eax
		1502	mov cl, 3 ; 3 chars for extension
		1503	dec esi
		1504	@@:
		1505	dec eax
		1506	cmp eax, esi
		1507	jbe .copy_process_ext_done
		1508	cmp byte [eax], '.'
		1509	jnz @b
		1510	lea esi, [eax+1]
		1511	.copy_process_ext_loop:
		1512	lodsb
		1513	test al, al
		1514	jz .copy_process_ext_done
		1515	stosb
		1516	loop .copy_process_ext_loop
		1517	.copy_process_ext_done:
		1518	mov al, ' '
		1519	rep stosb
		1520
		1521	; read header
		1522	lea eax, [esp+8+36]
		1523	mov edi, 0x90000
		1524	call dword [eax-4]
		1525	mov ecx, eax
		1526	neg ecx
		1527	jnz .cleanfailed
		1528	; check menuet signature
		1529	mov ecx, -0x1F
		1530	cmp dword [0x90000], 'MENU'
		1531	jnz .cleanfailed
		1532	cmp word [0x90004], 'ET'
		1533	jnz .cleanfailed
		1534	call get_app_params
		1535	mov ecx, -0x1F
133	diamond	1536	jc .cleanfailed
		1537	; sanity check - because we will load all file,
		1538	; file size must be not greater than memory size
		1539	mov eax, [esp+8+36]
		1540	cmp [app_mem], eax
		1541	jb .cleanfailed
129	mikedld	1542
		1543	mov eax, [new_process_place]
		1544	inc ecx ; -0x1E = no memory
		1545	call create_app_cr3_table
		1546	test eax, eax
		1547	jz .cleanfailed_mem
		1548
		1549	call MEM_Get_Linear_Address
		1550
		1551	mov ebx, std_application_base_address
		1552	mov ecx, [app_mem]
		1553	add ecx, 4095
		1554	shr ecx, 12
		1555	mov edx, eax ; edx - linear address of page directory
		1556	call mem_alloc_specified_region
		1557	mov ecx, -0x1E ; no memory
		1558	test eax, eax
		1559	jz .cleanfailed_mem1
		1560
		1561	add edx, std_application_base_address shr 20
		1562	mov eax, [edx]
		1563	and eax, not 4095
		1564	call MEM_Get_Linear_Address
		1565	push edx ; save pointer to first page table
		1566	mov edx, eax
		1567	; read file
		1568	; first block is already read to 0x90000
		1569	mov eax, [edx]
		1570	and eax, not 0xFFF
		1571	call MEM_Get_Linear_Address
		1572	mov esi, 0x90000
		1573	mov edi, eax
		1574	mov ecx, 512/4
		1575	rep movsd
		1576	sub edi, eax
		1577	.loop1:
		1578	; [esp] = pointer to current page directory entry
		1579	; edx = pointer to current page table
		1580	; edi = offset in page
		1581	mov eax, [edx]
		1582	and eax, not 0xFFF
		1583	call MEM_Get_Linear_Address
		1584	push edi
		1585	add edi, eax
		1586	lea eax, [esp+8+36+8]
		1587	call dword [eax-4]
		1588	pop edi
		1589	test eax, eax
		1590	jnz .endloop1
		1591	add edi, 512 ; new offset
		1592	cmp edi, 4096
		1593	jb .loop1
		1594	xor edi, edi
		1595	add edx, 4 ; go to next page
		1596	test edx, 4096-1
		1597	jnz .loop1
		1598	pop eax
		1599	add eax, 4 ; go to next directory entry
		1600	push eax
		1601	mov eax, [eax]
		1602	and eax, not 0xFFF
		1603	call MEM_Get_Linear_Address
		1604	mov edx, eax
		1605	jmp .loop1
		1606	.endloop1:
		1607	pop edx
		1608	cmp eax, 6
		1609	jnz .cleanfailed_mem2
		1610	call new_start_application_fl.add_app_parameters
		1611	mov [esp+28], eax
		1612	popad
		1613	ret
		1614
		1615	.cleanfailed_mem2:
		1616	; file read error; free all allocated mem
		1617	mov ecx, eax
		1618	neg ecx
		1619	mov eax, [new_process_place]
		1620	call dispose_app_cr3_table
		1621	jmp .cleanfailed
		1622	.cleanfailed_mem1:
		1623	; there is mem for directory entry, but there is no mem for pages
		1624	; so free directory entry
		1625	mov eax, [new_process_place]
		1626	shl eax, 8
		1627	mov eax, [0x80000+eax+0xB8]
		1628	call MEM_Free_Page
		1629	.cleanfailed_mem:
		1630	; there is no mem for directory entry, display message
		1631	mov esi, start_not_enough_memory
		1632	call sys_msg_board_str
		1633	.cleanfailed:
		1634	push ecx
		1635	; clean process name, this avoid problems with @panel
		1636	mov edi, [new_process_place]
		1637	shl edi, 8
		1638	add edi, 0x80000+APPDATA.app_name
		1639	mov ecx, 11
		1640	mov al, ' '
		1641	rep stosb
		1642	pop eax
		1643	.failed:
		1644	pop ebx
		1645	mov [esp+28], eax
		1646	popad
		1647	mov [application_table_status], 0
		1648	call safe_sti
		1649	ret
		1650	; \end{diamond}

Subversion Repositories Kolibri OS

(root)/kernel/branches/gfx_kernel/core/newproce.inc – Rev 133