WebSVN – Kolibri OS – Blame – /kernel/trunk/core/dll.inc

Rev	Author	Line No.	Line
2288	clevermous	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
		2	;; ;;
9715	Doczom	3	;; Copyright (C) KolibriOS team 2004-2022. All rights reserved. ;;
6502	pathoswith	4	;; Distributed under terms of the GNU General Public License. ;;
2288	clevermous	5	;; ;;
		6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
		7
		8	$Revision: 9976 $
		9
		10
7136	dunkaist	11	DRV_COMPAT = 5 ;minimal required drivers version
		12	DRV_CURRENT = 6 ;current drivers model version
2288	clevermous	13
7136	dunkaist	14	DRV_VERSION = (DRV_COMPAT shl 16) or DRV_CURRENT
		15	PID_KERNEL = 1 ;os_idle thread
2288	clevermous	16
		17
		18
		19	align 4
		20	proc get_notify stdcall, p_ev:dword
		21
		22	.wait:
		23	mov ebx, [current_slot]
9715	Doczom	24	test dword [ebx + APPDATA.event_mask], EVENT_NOTIFY
2288	clevermous	25	jz @f
9715	Doczom	26	and dword [ebx + APPDATA.event_mask], not EVENT_NOTIFY
2288	clevermous	27	mov edi, [p_ev]
		28	mov dword [edi], EV_INTR
9715	Doczom	29	mov eax, [ebx + APPDATA.event]
2288	clevermous	30	mov dword [edi+4], eax
		31	ret
		32	@@:
		33	call change_task
		34	jmp .wait
		35	endp
		36
		37
		38
		39	handle equ IOCTL.handle
		40	io_code equ IOCTL.io_code
		41	input equ IOCTL.input
		42	inp_size equ IOCTL.inp_size
		43	output equ IOCTL.output
		44	out_size equ IOCTL.out_size
		45
		46
		47	align 4
		48	proc srv_handler stdcall, ioctl:dword
		49	mov esi, [ioctl]
		50	test esi, esi
		51	jz .err
		52
9715	Doczom	53	mov edi, [esi + handle]
		54	cmp [edi + SRV.magic], ' SRV'
2288	clevermous	55	jne .fail
		56
9715	Doczom	57	cmp [edi + SRV.size], sizeof.SRV
2288	clevermous	58	jne .fail
		59
3520	clevermous	60	; stdcall [edi+SRV.srv_proc], esi
9715	Doczom	61	mov eax, [edi + SRV.srv_proc]
3520	clevermous	62	test eax, eax
		63	jz .fail
		64	stdcall eax, esi
2288	clevermous	65	ret
		66	.fail:
		67	xor eax, eax
		68	not eax
9715	Doczom	69	mov [esi + output], eax
		70	mov [esi + out_size], 4
2288	clevermous	71	ret
		72	.err:
		73	xor eax, eax
		74	not eax
		75	ret
		76	endp
		77
		78	; param
		79	; ecx= io_control
		80	;
		81	; retval
		82	; eax= error code
		83
		84	align 4
		85	srv_handlerEx:
		86	cmp ecx, OS_BASE
		87	jae .fail
		88
9715	Doczom	89	mov eax, [ecx + handle]
9430	Doczom	90
		91	cmp eax, OS_BASE
9440	Doczom	92	jbe .fail
9430	Doczom	93
9715	Doczom	94	cmp [eax + SRV.magic], ' SRV'
2288	clevermous	95	jne .fail
		96
9715	Doczom	97	cmp [eax + SRV.size], sizeof.SRV
2288	clevermous	98	jne .fail
		99
3520	clevermous	100	; stdcall [eax+SRV.srv_proc], ecx
9715	Doczom	101	mov eax, [eax + SRV.srv_proc]
3520	clevermous	102	test eax, eax
		103	jz .fail
		104	stdcall eax, ecx
2288	clevermous	105	ret
		106	.fail:
		107	or eax, -1
		108	ret
		109
		110	restore handle
		111	restore io_code
		112	restore input
		113	restore inp_size
		114	restore output
		115	restore out_size
		116
		117	align 4
		118	proc get_service stdcall, sz_name:dword
		119	mov eax, [sz_name]
		120	test eax, eax
		121	jnz @F
		122	ret
		123	@@:
		124	mov edx, [srv.fd]
		125	@@:
9715	Doczom	126	cmp edx, srv.fd - SRV.fd
2288	clevermous	127	je .not_load
		128
		129	stdcall strncmp, edx, [sz_name], 16
		130	test eax, eax
5088	clevermous	131	mov eax, edx
		132	je .nothing
2288	clevermous	133
9715	Doczom	134	mov edx, [edx + SRV.fd]
2288	clevermous	135	jmp @B
		136	.not_load:
4418	clevermous	137	mov eax, [sz_name]
		138	push edi
		139	sub esp, 36
		140	mov edi, esp
		141	mov dword [edi], '/sys'
		142	mov dword [edi+4], '/dri'
		143	mov dword [edi+8], 'vers'
		144	mov byte [edi+12], '/'
		145	@@:
		146	mov dl, [eax]
		147	mov [edi+13], dl
		148	inc eax
		149	inc edi
		150	test dl, dl
		151	jnz @b
		152	mov dword [edi+12], '.sys'
		153	mov byte [edi+16], 0
		154	mov edi, esp
		155	stdcall load_pe_driver, edi, 0
		156	add esp, 36
		157	pop edi
		158	.nothing:
2288	clevermous	159	ret
		160	endp
		161
3520	clevermous	162	reg_service:
		163	xor eax, eax
		164	mov ecx, [esp+8]
9872	Doczom	165	;jecxz .nothing
3520	clevermous	166	push sizeof.SRV
		167	push ecx
		168	pushd [esp+12]
		169	call reg_service_ex
		170	.nothing:
		171	ret 8
2288	clevermous	172
3520	clevermous	173	reg_usb_driver:
		174	push sizeof.USBSRV
		175	pushd [esp+12]
		176	pushd [esp+12]
		177	call reg_service_ex
		178	test eax, eax
		179	jz .nothing
		180	mov ecx, [esp+12]
		181	mov [eax+USBSRV.usb_func], ecx
		182	.nothing:
		183	ret 12
		184
		185	proc reg_service_ex stdcall, name:dword, handler:dword, srvsize:dword
		186
2288	clevermous	187	push ebx
		188
		189	xor eax, eax
		190
		191	cmp [name], eax
		192	je .fail
		193
3520	clevermous	194	; cmp [handler], eax
		195	; je .fail
2288	clevermous	196
3520	clevermous	197	mov eax, [srvsize]
2288	clevermous	198	call malloc
		199	test eax, eax
		200	jz .fail
		201
		202	push esi
		203	push edi
		204	mov edi, eax
		205	mov esi, [name]
		206	movsd
		207	movsd
		208	movsd
		209	movsd
		210	pop edi
		211	pop esi
		212
9715	Doczom	213	mov [eax + SRV.magic], ' SRV'
		214	mov [eax + SRV.size], sizeof.SRV
2288	clevermous	215
9715	Doczom	216	mov ebx, srv.fd - SRV.fd
		217	mov edx, [ebx + SRV.fd]
		218	mov [eax + SRV.fd], edx
		219	mov [eax + SRV.bk], ebx
		220	mov [ebx + SRV.fd], eax
		221	mov [edx + SRV.bk], eax
2288	clevermous	222
		223	mov ecx, [handler]
9715	Doczom	224	mov [eax + SRV.srv_proc], ecx
9440	Doczom	225	;dec [count_services]
2288	clevermous	226	pop ebx
		227	ret
		228	.fail:
		229	xor eax, eax
		230	pop ebx
		231	ret
		232	endp
		233
		234	align 4
9567	Doczom	235	stop_all_services: ;used in shutdown system
		236	push ebp
		237	mov edx, [srv.fd]
		238	.next:
9715	Doczom	239	cmp edx, srv.fd - SRV.fd
9567	Doczom	240	je .done
9715	Doczom	241	cmp [edx + SRV.magic], ' SRV'
9567	Doczom	242	jne .next
9715	Doczom	243	cmp [edx + SRV.size], sizeof.SRV
9567	Doczom	244	jne .next
		245
9715	Doczom	246	mov ebx, [edx + SRV.entry]
		247	mov edx, [edx + SRV.fd]
9567	Doczom	248	test ebx, ebx
		249	jz .next
		250
		251	push edx
		252	mov ebp, esp
		253	push 0
		254	push DRV_EXIT
		255	call ebx ;stdcall
		256	mov esp, ebp
		257	pop edx
		258	jmp .next
		259	.done:
		260	pop ebp
		261	ret
		262
		263	align 4
2288	clevermous	264	proc get_proc stdcall, exp:dword, sz_name:dword
		265
		266	mov edx, [exp]
		267	.next:
		268	mov eax, [edx]
		269	test eax, eax
		270	jz .end
		271
		272	push edx
		273	stdcall strncmp, eax, [sz_name], 16
		274	pop edx
		275	test eax, eax
		276	jz .ok
		277
		278	add edx, 8
		279	jmp .next
		280	.ok:
		281	mov eax, [edx+4]
		282	.end:
		283	ret
		284	endp
		285
		286	align 4
		287	proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword
		288
		289	@@:
9823	dunkaist	290	stdcall strncmp, [pSym], [sz_sym], sizeof.COFF_SYM.Name
2288	clevermous	291	test eax, eax
		292	jz .ok
9823	dunkaist	293	add [pSym], sizeof.COFF_SYM
2288	clevermous	294	dec [count]
		295	jnz @b
		296	xor eax, eax
		297	ret
		298	.ok:
		299	mov eax, [pSym]
9823	dunkaist	300	mov eax, [eax+COFF_SYM.Value]
2288	clevermous	301	ret
		302	endp
		303
		304
		305	align 4
		306	proc get_fileinfo stdcall, file_name:dword, info:dword
		307	locals
		308	cmd dd ?
		309	offset dd ?
		310	dd ?
		311	count dd ?
		312	buff dd ?
		313	db ?
		314	name dd ?
		315	endl
		316
		317	xor eax, eax
		318	mov ebx, [file_name]
		319	mov ecx, [info]
		320
		321	mov [cmd], 5
		322	mov [offset], eax
		323	mov [offset+4], eax
		324	mov [count], eax
		325	mov [buff], ecx
		326	mov byte [buff+4], al
		327	mov [name], ebx
		328
		329	mov eax, 70
		330	lea ebx, [cmd]
8680	rgimad	331	pushad
		332	cld
		333	call protect_from_terminate
		334	call file_system_lfn
		335	call unprotect_from_terminate
		336	popad
2288	clevermous	337	ret
		338	endp
		339
		340	align 4
		341	proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\
		342	bytes:dword
		343	locals
		344	cmd dd ?
		345	offset dd ?
		346	dd ?
		347	count dd ?
		348	buff dd ?
		349	db ?
		350	name dd ?
		351	endl
		352
		353	xor eax, eax
		354	mov ebx, [file_name]
		355	mov ecx, [off]
		356	mov edx, [bytes]
		357	mov esi, [buffer]
		358
		359	mov [cmd], eax
		360	mov [offset], ecx
		361	mov [offset+4], eax
		362	mov [count], edx
		363	mov [buff], esi
		364	mov byte [buff+4], al
		365	mov [name], ebx
		366
		367	pushad
		368	lea ebx, [cmd]
3296	clevermous	369	call file_system_lfn_protected
2288	clevermous	370	popad
		371	ret
		372	endp
		373
9034	Boppan	374	align 4
		375	; @brief Allocate kernel memory and loads the specified file
2288	clevermous	376	;
9034	Boppan	377	; @param file_name Path to file
2288	clevermous	378	;
9034	Boppan	379	; @returns File image in kernel memory in `eax` and size of file in `ebx`
2288	clevermous	380	;
9034	Boppan	381	; @warning You must call kernel_free() to delete each file loaded by the
		382	; load_file() function
2288	clevermous	383	proc load_file stdcall, file_name:dword
		384	locals
		385	attr dd ?
		386	flags dd ?
		387	cr_time dd ?
		388	cr_date dd ?
		389	acc_time dd ?
		390	acc_date dd ?
		391	mod_time dd ?
		392	mod_date dd ?
		393	file_size dd ?
		394
		395	file dd ?
		396	file2 dd ?
		397	endl
		398
		399	push esi
		400	push edi
		401
		402	lea eax, [attr]
		403	stdcall get_fileinfo, [file_name], eax
		404	test eax, eax
		405	jnz .fail
		406
		407	mov eax, [file_size]
		408	cmp eax, 1024102416
		409	ja .fail
		410
		411	stdcall kernel_alloc, [file_size]
		412	mov [file], eax
		413	test eax, eax
		414	jz .fail
		415
		416	stdcall read_file, [file_name], eax, dword 0, [file_size]
		417	cmp ebx, [file_size]
		418	jne .cleanup
		419
		420	mov eax, [file]
7122	dunkaist	421	cmp dword [eax], 'KPCK'
2288	clevermous	422	jne .exit
		423	mov ebx, [eax+4]
		424	mov [file_size], ebx
		425	stdcall kernel_alloc, ebx
		426
		427	test eax, eax
		428	jz .cleanup
		429
		430	mov [file2], eax
2486	mario79	431
2500	mario79	432	pushad
2489	mario79	433	mov ecx, unpack_mutex
		434	call mutex_lock
2500	mario79	435	popad
2486	mario79	436
2288	clevermous	437	stdcall unpack, [file], eax
2486	mario79	438
2500	mario79	439	pushad
		440	mov ecx, unpack_mutex
2489	mario79	441	call mutex_unlock
2500	mario79	442	popad
2486	mario79	443
2288	clevermous	444	stdcall kernel_free, [file]
		445	mov eax, [file2]
		446	mov ebx, [file_size]
		447	.exit:
		448	push eax
		449	lea edi, [eax+ebx] ;cleanup remain space
		450	mov ecx, 4096 ;from file end
		451	and ebx, 4095
		452	jz @f
		453	sub ecx, ebx
		454	xor eax, eax
		455	cld
		456	rep stosb
		457	@@:
		458	mov ebx, [file_size]
		459	pop eax
		460	pop edi
		461	pop esi
		462	ret
		463	.cleanup:
		464	stdcall kernel_free, [file]
		465	.fail:
		466	xor eax, eax
		467	xor ebx, ebx
		468	pop edi
		469	pop esi
		470	ret
		471	endp
		472
3786	Serge	473	; description
		474	; allocate user memory and loads the specified file
		475	;
		476	; param
		477	; file_name= path to file
		478	;
		479	; retval
		480	; eax= file image in user memory
		481	; ebx= size of file
		482	;
		483	; warging
		484	; You mast call kernel_free() to delete each file
		485	; loaded by the load_file() function
		486
		487	align 4
		488	proc load_file_umode stdcall, file_name:dword
		489	locals
		490	attr dd ?
		491	flags dd ?
		492	cr_time dd ?
		493	cr_date dd ?
		494	acc_time dd ?
		495	acc_date dd ?
		496	mod_time dd ?
		497	mod_date dd ?
		498	file_size dd ?
		499
		500	km_file dd ?
		501	um_file dd ?
		502	endl
		503
		504	push esi
		505	push edi
		506	push ebx
		507
		508	lea eax, [attr]
		509	stdcall get_fileinfo, [file_name], eax ;find file and get info
		510	test eax, eax
		511	jnz .err_1
		512
		513	mov eax, [file_size]
9976	Jurgen	514	cmp eax, 102410241024 ;to be enough for anybody 1Gbt(c)
3786	Serge	515	ja .err_1
		516	;it is very likely that the file is packed
		517	stdcall kernel_alloc, [file_size] ;with kpack, so allocate memory from kernel heap
		518	mov [km_file], eax
		519	test eax, eax
		520	jz .err_1
		521
		522	stdcall read_file, [file_name], eax, dword 0, [file_size]
		523	cmp ebx, [file_size]
		524
		525	jne .err_2
		526
		527	mov eax, [km_file]
7122	dunkaist	528	cmp dword [eax], 'KPCK' ; check kpack signature
3786	Serge	529	jne .raw_file
		530
		531	mov ebx, [eax+4] ;get real size of file
		532	mov [file_size], ebx
4237	Serge	533	stdcall user_alloc, ebx ;and allocate space from user heap
3786	Serge	534	mov [um_file], eax
		535	test eax, eax
		536	jz .err_2
		537
4237	Serge	538	mov edx, [file_size] ;preallocate page memory
		539	shr eax, 10
9715	Doczom	540	lea edi, [page_tabs + eax]
4237	Serge	541	add edx, 4095
		542	shr edx, 12
		543	@@:
		544	call alloc_page
		545	test eax, eax
		546	jz .err_3
		547
5356	serge	548	or eax, PG_UWR
4237	Serge	549	stosd
		550	dec edx
		551	jnz @B
		552
3786	Serge	553	pushad
		554	mov ecx, unpack_mutex
		555	call mutex_lock
		556
		557	stdcall unpack, [km_file], [um_file]
		558
		559	mov ecx, unpack_mutex
		560	call mutex_unlock
		561	popad
		562
		563	stdcall kernel_free, [km_file] ;we don't need packed file anymore
		564	.exit:
4237	Serge	565
		566	mov edi, [um_file]
		567	mov esi, [um_file]
		568	mov eax, [file_size]
		569	mov edx, eax
		570
		571	add edi, eax ;cleanup remain space
		572	mov ecx, 4096 ;from file end
		573	and eax, 4095
		574	jz @f
		575	sub ecx, eax
		576	xor eax, eax
		577	cld
		578	rep stosb
		579	@@:
3786	Serge	580	mov eax, [um_file]
		581
		582	pop ebx
		583	pop edi
		584	pop esi
		585	ret
		586
		587	.raw_file: ; sometimes we load unpacked file
		588	stdcall user_alloc, ebx ; allocate space from user heap
		589	mov [um_file], eax
		590
		591	test eax, eax
		592	jz .err_2
		593
		594	shr eax, 10 ; and remap pages.
		595
		596	mov ecx, [file_size]
		597	add ecx, 4095
		598	shr ecx, 12
		599
		600	mov esi, [km_file]
		601	shr esi, 10
		602	add esi, page_tabs
		603
		604	lea edi, [page_tabs+eax]
		605
		606	cld
		607	@@:
		608	lodsd
		609	and eax, 0xFFFFF000
5356	serge	610	or eax, PG_UWR
3786	Serge	611	stosd
		612	loop @B
		613
		614	stdcall free_kernel_space, [km_file] ; release allocated kernel space
		615	jmp .exit ; physical pages still in use
4237	Serge	616	.err_3:
		617	stdcall user_free, [um_file]
3786	Serge	618	.err_2:
		619	stdcall kernel_free, [km_file]
		620	.err_1:
		621	xor eax, eax
		622	xor edx, edx
		623
		624	pop ebx
		625	pop edi
		626	pop esi
		627	ret
		628	endp
		629
		630
2489	mario79	631	uglobal
2288	clevermous	632	align 4
2489	mario79	633	unpack_mutex MUTEX
2486	mario79	634	endg
		635
		636	align 4
3761	clevermous	637	proc get_proc_ex stdcall uses ebx esi, proc_name:dword, imports:dword
		638	mov ebx, [imports]
		639	test ebx, ebx
		640	jz .end
		641	xor esi, esi
2288	clevermous	642	.look_up:
		643
3761	clevermous	644	mov eax, [ebx+32]
9715	Doczom	645	mov eax, [OS_BASE + eax + esi*4]
3761	clevermous	646	add eax, OS_BASE
2288	clevermous	647	stdcall strncmp, eax, [proc_name], 256
		648	test eax, eax
		649	jz .ok
		650
3761	clevermous	651	inc esi
		652	cmp esi, [ebx+24]
		653	jb .look_up
2288	clevermous	654	.end:
		655	xor eax, eax
		656	ret
3761	clevermous	657	.ok:
		658	mov eax, [ebx+28]
9715	Doczom	659	mov eax, [OS_BASE + eax + esi*4]
3761	clevermous	660	add eax, OS_BASE
		661	ret
2288	clevermous	662	endp
		663
		664	align 4
		665	proc fix_coff_symbols stdcall uses ebx esi, sec:dword, symbols:dword,\
		666	sym_count:dword, strings:dword, imports:dword
		667	locals
		668	retval dd ?
		669	endl
		670
		671	mov edi, [symbols]
		672	mov [retval], 1
		673	.fix:
9715	Doczom	674	movzx ebx, [edi + COFF_SYM.SectionNumber]
2288	clevermous	675	test ebx, ebx
		676	jnz .internal
9715	Doczom	677	mov eax, dword [edi + COFF_SYM.Name]
2288	clevermous	678	test eax, eax
		679	jnz @F
		680
		681	mov edi, [edi+4]
		682	add edi, [strings]
		683	@@:
		684	push edi
		685	stdcall get_proc_ex, edi, [imports]
		686	pop edi
		687
		688	xor ebx, ebx
		689	test eax, eax
		690	jnz @F
		691
5998	veliant	692	; disable debug msg
		693	;mov esi, msg_unresolved
		694	;call sys_msg_board_str
		695	;mov esi, edi
		696	;call sys_msg_board_str
		697	;mov esi, msg_CR
		698	;call sys_msg_board_str
2288	clevermous	699
		700	mov [retval], 0
		701	@@:
		702	mov edi, [symbols]
9715	Doczom	703	mov [edi + COFF_SYM.Value], eax
2288	clevermous	704	jmp .next
		705	.internal:
		706	cmp bx, -1
		707	je .next
		708	cmp bx, -2
		709	je .next
		710
		711	dec ebx
		712	shl ebx, 3
9715	Doczom	713	lea ebx, [ebx + ebx*4]
2288	clevermous	714	add ebx, [sec]
		715
9715	Doczom	716	mov eax, [ebx + COFF_SECTION.VirtualAddress]
		717	add [edi + COFF_SYM.Value], eax
2288	clevermous	718	.next:
2384	hidnplayr	719	add edi, sizeof.COFF_SYM
2288	clevermous	720	mov [symbols], edi
		721	dec [sym_count]
		722	jnz .fix
		723	mov eax, [retval]
		724	ret
		725	endp
		726
		727	align 4
		728	proc fix_coff_relocs stdcall uses ebx esi, coff:dword, sym:dword, \
		729	delta:dword
		730	locals
		731	n_sec dd ?
		732	endl
		733
		734	mov eax, [coff]
9715	Doczom	735	movzx ebx, [eax + COFF_HEADER.nSections]
2288	clevermous	736	mov [n_sec], ebx
		737	lea esi, [eax+20]
		738	.fix_sec:
9715	Doczom	739	mov edi, [esi + COFF_SECTION.PtrReloc]
2288	clevermous	740	add edi, [coff]
		741
9715	Doczom	742	movzx ecx, [esi + COFF_SECTION.NumReloc]
2288	clevermous	743	test ecx, ecx
		744	jz .next
		745	.reloc_loop:
9715	Doczom	746	mov ebx, [edi + COFF_RELOC.SymIndex]
2288	clevermous	747	add ebx, ebx
		748	lea ebx, [ebx+ebx*8]
		749	add ebx, [sym]
		750
9715	Doczom	751	mov edx, [ebx + COFF_SYM.Value]
2288	clevermous	752
9715	Doczom	753	cmp [edi + COFF_RELOC.Type], 6
2288	clevermous	754	je .dir_32
		755
9715	Doczom	756	cmp [edi + COFF_RELOC.Type], 20
2288	clevermous	757	jne .next_reloc
		758	.rel_32:
9715	Doczom	759	mov eax, [edi + COFF_RELOC.VirtualAddress]
		760	add eax, [esi + COFF_SECTION.VirtualAddress]
2288	clevermous	761	sub edx, eax
		762	sub edx, 4
		763	jmp .fix
		764	.dir_32:
9715	Doczom	765	mov eax, [edi + COFF_RELOC.VirtualAddress]
		766	add eax, [esi + COFF_SECTION.VirtualAddress]
2288	clevermous	767	.fix:
		768	add eax, [delta]
		769	add [eax], edx
		770	.next_reloc:
		771	add edi, 10
		772	dec ecx
		773	jnz .reloc_loop
		774	.next:
2384	hidnplayr	775	add esi, sizeof.COFF_SECTION
2288	clevermous	776	dec [n_sec]
		777	jnz .fix_sec
		778	.exit:
		779	ret
		780	endp
		781
		782	align 4
		783	proc rebase_coff stdcall uses ebx esi, coff:dword, sym:dword, \
		784	delta:dword
		785	locals
		786	n_sec dd ?
		787	endl
		788
		789	mov eax, [coff]
9715	Doczom	790	movzx ebx, [eax + COFF_HEADER.nSections]
2288	clevermous	791	mov [n_sec], ebx
		792	lea esi, [eax+20]
		793	mov edx, [delta]
		794	.fix_sec:
9715	Doczom	795	mov edi, [esi + COFF_SECTION.PtrReloc]
2288	clevermous	796	add edi, [coff]
		797
9715	Doczom	798	movzx ecx, [esi + COFF_SECTION.NumReloc]
2288	clevermous	799	test ecx, ecx
		800	jz .next
		801	.reloc_loop:
9715	Doczom	802	cmp [edi + COFF_RELOC.Type], 6
2288	clevermous	803	jne .next_reloc
		804	.dir_32:
9715	Doczom	805	mov eax, [edi + COFF_RELOC.VirtualAddress]
		806	add eax, [esi + COFF_SECTION.VirtualAddress]
		807	add [eax + edx], edx
2288	clevermous	808	.next_reloc:
		809	add edi, 10
		810	dec ecx
		811	jnz .reloc_loop
		812	.next:
2384	hidnplayr	813	add esi, sizeof.COFF_SECTION
2288	clevermous	814	dec [n_sec]
		815	jnz .fix_sec
		816	.exit:
		817	ret
		818	endp
		819
		820	; in: edx -> COFF_SECTION struct
		821	; out: eax = alignment as mask for bits to drop
		822	coff_get_align:
		823	; Rules:
		824	; - if alignment is not given, use default = 4K;
		825	; - if alignment is given and is no more than 4K, use it;
		826	; - if alignment is more than 4K, revert to 4K.
		827	push ecx
9715	Doczom	828	mov cl, byte [edx + COFF_SECTION.Characteristics+2]
2288	clevermous	829	mov eax, 1
		830	shr cl, 4
		831	dec cl
		832	js .default
		833	cmp cl, 12
		834	jbe @f
		835	.default:
		836	mov cl, 12
		837	@@:
		838	shl eax, cl
		839	pop ecx
		840	dec eax
		841	ret
		842
		843	align 4
6792	pathoswith	844	proc load_library stdcall, file_name:dword, encoding:dword
6502	pathoswith	845	locals
		846	fullname dd ?
		847	fileinfo rb 40
		848	coff dd ?
		849	img_base dd ?
		850	endl
2288	clevermous	851
		852	; resolve file name
6502	pathoswith	853	stdcall kernel_alloc, maxPathLength
		854	mov [fullname], eax
6792	pathoswith	855	mov edi, eax
		856	mov esi, [file_name]
		857	mov eax, [encoding]
		858	push ebp
		859	call getFullPath
		860	pop ebp
6502	pathoswith	861	test eax, eax
2288	clevermous	862	jz .fail
		863	; scan for required DLL in list of already loaded for this process,
		864	; ignore timestamp
3827	clevermous	865	cli
5130	serge	866	mov esi, [current_process]
6502	pathoswith	867	mov edi, [fullname]
9715	Doczom	868	mov ebx, [esi + PROC.dlls_list_ptr]
2288	clevermous	869	test ebx, ebx
		870	jz .not_in_process
9715	Doczom	871	mov esi, [ebx + HDLL.fd]
2288	clevermous	872	.scan_in_process:
		873	cmp esi, ebx
		874	jz .not_in_process
9715	Doczom	875	mov eax, [esi + HDLL.parent]
2288	clevermous	876	add eax, DLLDESCR.name
		877	stdcall strncmp, eax, edi, -1
		878	test eax, eax
		879	jnz .next_in_process
		880	; simple variant: load DLL which is already loaded in this process
		881	; just increment reference counters and return address of exports table
9715	Doczom	882	inc [esi + HDLL.refcount]
		883	mov ecx, [esi + HDLL.parent]
		884	inc [ecx + DLLDESCR.refcount]
		885	mov eax, [ecx + DLLDESCR.exports]
		886	sub eax, [ecx + DLLDESCR.defaultbase]
		887	add eax, [esi + HDLL.base]
3827	clevermous	888	sti
6502	pathoswith	889	push eax
		890	stdcall kernel_free, [fullname]
		891	pop eax
2288	clevermous	892	ret
6502	pathoswith	893
2288	clevermous	894	.next_in_process:
9715	Doczom	895	mov esi, [esi + HDLL.fd]
2288	clevermous	896	jmp .scan_in_process
6502	pathoswith	897
2288	clevermous	898	.not_in_process:
		899	; scan in full list, compare timestamp
3827	clevermous	900	sti
2288	clevermous	901	lea eax, [fileinfo]
		902	stdcall get_fileinfo, edi, eax
		903	test eax, eax
		904	jnz .fail
3827	clevermous	905	cli
2288	clevermous	906	mov esi, [dll_list.fd]
		907	.scan_for_dlls:
		908	cmp esi, dll_list
		909	jz .load_new
9715	Doczom	910	lea eax, [esi + DLLDESCR.name]
2288	clevermous	911	stdcall strncmp, eax, edi, -1
		912	test eax, eax
		913	jnz .continue_scan
		914	.test_prev_dll:
		915	mov eax, dword [fileinfo+24]; last modified time
		916	mov edx, dword [fileinfo+28]; last modified date
9715	Doczom	917	cmp dword [esi + DLLDESCR.timestamp], eax
2288	clevermous	918	jnz .continue_scan
9715	Doczom	919	cmp dword [esi + DLLDESCR.timestamp+4], edx
2288	clevermous	920	jz .dll_already_loaded
		921	.continue_scan:
9715	Doczom	922	mov esi, [esi + DLLDESCR.fd]
2288	clevermous	923	jmp .scan_for_dlls
		924
		925	; new DLL
		926	.load_new:
3827	clevermous	927	sti
2288	clevermous	928	; load file
		929	stdcall load_file, edi
		930	test eax, eax
		931	jz .fail
		932	mov [coff], eax
		933	mov dword [fileinfo+32], ebx
		934
		935	; allocate DLLDESCR struct; size is DLLDESCR.sizeof plus size of DLL name
		936	mov esi, edi
		937	mov ecx, -1
		938	xor eax, eax
		939	repnz scasb
		940	not ecx
9715	Doczom	941	lea eax, [ecx + sizeof.DLLDESCR]
2288	clevermous	942	push ecx
		943	call malloc
		944	pop ecx
		945	test eax, eax
		946	jz .fail_and_free_coff
		947	; save timestamp
9715	Doczom	948	lea edi, [eax + DLLDESCR.name]
2288	clevermous	949	rep movsb
		950	mov esi, eax
		951	mov eax, dword [fileinfo+24]
9715	Doczom	952	mov dword [esi + DLLDESCR.timestamp], eax
2288	clevermous	953	mov eax, dword [fileinfo+28]
9715	Doczom	954	mov dword [esi + DLLDESCR.timestamp+4], eax
2288	clevermous	955
		956	; calculate size of loaded DLL
		957	mov edx, [coff]
9715	Doczom	958	movzx ecx, [edx + COFF_HEADER.nSections]
2288	clevermous	959	xor ebx, ebx
		960
9823	dunkaist	961	add edx, sizeof.COFF_HEADER
2288	clevermous	962	@@:
		963	call coff_get_align
		964	add ebx, eax
		965	not eax
		966	and ebx, eax
9715	Doczom	967	add ebx, [edx + COFF_SECTION.SizeOfRawData]
2384	hidnplayr	968	add edx, sizeof.COFF_SECTION
2288	clevermous	969	dec ecx
		970	jnz @B
		971	; it must be nonzero and not too big
9715	Doczom	972	mov [esi + DLLDESCR.size], ebx
2288	clevermous	973	test ebx, ebx
		974	jz .fail_and_free_dll
		975	cmp ebx, MAX_DEFAULT_DLL_ADDR-MIN_DEFAULT_DLL_ADDR
		976	ja .fail_and_free_dll
		977	; allocate memory for kernel-side image
		978	stdcall kernel_alloc, ebx
		979	test eax, eax
		980	jz .fail_and_free_dll
9715	Doczom	981	mov [esi + DLLDESCR.data], eax
2288	clevermous	982	; calculate preferred base address
		983	add ebx, 0x1FFF
		984	and ebx, not 0xFFF
		985	mov ecx, [dll_cur_addr]
9715	Doczom	986	lea edx, [ecx + ebx]
2288	clevermous	987	cmp edx, MAX_DEFAULT_DLL_ADDR
		988	jb @f
		989	mov ecx, MIN_DEFAULT_DLL_ADDR
9715	Doczom	990	lea edx, [ecx + ebx]
2288	clevermous	991	@@:
9715	Doczom	992	mov [esi + DLLDESCR.defaultbase], ecx
2288	clevermous	993	mov [dll_cur_addr], edx
		994
		995	; copy sections and set correct values for VirtualAddress'es in headers
		996	push esi
		997	mov edx, [coff]
9715	Doczom	998	movzx ebx, [edx + COFF_HEADER.nSections]
2288	clevermous	999	mov edi, eax
		1000	add edx, 20
		1001	cld
		1002	@@:
		1003	call coff_get_align
		1004	add ecx, eax
		1005	add edi, eax
		1006	not eax
		1007	and ecx, eax
		1008	and edi, eax
9715	Doczom	1009	mov [edx + COFF_SECTION.VirtualAddress], ecx
		1010	add ecx, [edx + COFF_SECTION.SizeOfRawData]
		1011	mov esi, [edx + COFF_SECTION.PtrRawData]
2288	clevermous	1012	push ecx
9715	Doczom	1013	mov ecx, [edx + COFF_SECTION.SizeOfRawData]
2288	clevermous	1014	test esi, esi
		1015	jnz .copy
		1016	xor eax, eax
		1017	rep stosb
		1018	jmp .next
		1019	.copy:
		1020	add esi, [coff]
		1021	rep movsb
		1022	.next:
		1023	pop ecx
2384	hidnplayr	1024	add edx, sizeof.COFF_SECTION
2288	clevermous	1025	dec ebx
		1026	jnz @B
		1027	pop esi
		1028
		1029	; save some additional data from COFF file
		1030	; later we will use COFF header, headers for sections and symbol table
		1031	; and also relocations table for all sections
		1032	mov edx, [coff]
9715	Doczom	1033	mov ebx, [edx + COFF_HEADER.pSymTable]
2288	clevermous	1034	mov edi, dword [fileinfo+32]
		1035	sub edi, ebx
		1036	jc .fail_and_free_data
9715	Doczom	1037	mov [esi + DLLDESCR.symbols_lim], edi
2288	clevermous	1038	add ebx, edx
9715	Doczom	1039	movzx ecx, [edx + COFF_HEADER.nSections]
2288	clevermous	1040	lea ecx, [ecx*5]
9715	Doczom	1041	lea edi, [edi + ecx*8+20]
9823	dunkaist	1042	add edx, sizeof.COFF_HEADER
2288	clevermous	1043	@@:
9715	Doczom	1044	movzx eax, [edx + COFF_SECTION.NumReloc]
2288	clevermous	1045	lea eax, [eax*5]
9715	Doczom	1046	lea edi, [edi + eax*2]
2384	hidnplayr	1047	add edx, sizeof.COFF_SECTION
2288	clevermous	1048	sub ecx, 5
		1049	jnz @b
		1050	stdcall kernel_alloc, edi
		1051	test eax, eax
		1052	jz .fail_and_free_data
		1053	mov edx, [coff]
9715	Doczom	1054	movzx ecx, [edx + COFF_HEADER.nSections]
2288	clevermous	1055	lea ecx, [ecx*5]
		1056	lea ecx, [ecx*2+5]
9715	Doczom	1057	mov [esi + DLLDESCR.coff_hdr], eax
2288	clevermous	1058	push esi
		1059	mov esi, edx
		1060	mov edi, eax
		1061	rep movsd
		1062	pop esi
9715	Doczom	1063	mov [esi + DLLDESCR.symbols_ptr], edi
2288	clevermous	1064	push esi
2384	hidnplayr	1065	mov ecx, [edx+COFF_HEADER.nSymbols]
9715	Doczom	1066	mov [esi + DLLDESCR.symbols_num], ecx
		1067	mov ecx, [esi + DLLDESCR.symbols_lim]
2288	clevermous	1068	mov esi, ebx
		1069	rep movsb
		1070	pop esi
9715	Doczom	1071	mov ebx, [esi + DLLDESCR.coff_hdr]
2288	clevermous	1072	push esi
9715	Doczom	1073	movzx eax, [edx + COFF_HEADER.nSections]
2288	clevermous	1074	lea edx, [ebx+20]
		1075	@@:
9715	Doczom	1076	movzx ecx, [edx + COFF_SECTION.NumReloc]
2288	clevermous	1077	lea ecx, [ecx*5]
9715	Doczom	1078	mov esi, [edx + COFF_SECTION.PtrReloc]
		1079	mov [edx + COFF_SECTION.PtrReloc], edi
		1080	sub [edx + COFF_SECTION.PtrReloc], ebx
2288	clevermous	1081	add esi, [coff]
		1082	shr ecx, 1
		1083	rep movsd
		1084	adc ecx, ecx
		1085	rep movsw
2384	hidnplayr	1086	add edx, sizeof.COFF_SECTION
2288	clevermous	1087	dec eax
		1088	jnz @b
		1089	pop esi
		1090
		1091	; fixup symbols
		1092	mov edx, ebx
9715	Doczom	1093	mov eax, [ebx + COFF_HEADER.nSymbols]
9823	dunkaist	1094	add edx, sizeof.COFF_HEADER
9715	Doczom	1095	mov ecx, [esi + DLLDESCR.symbols_num]
2288	clevermous	1096	lea ecx, [ecx*9]
		1097	add ecx, ecx
9715	Doczom	1098	add ecx, [esi + DLLDESCR.symbols_ptr]
2288	clevermous	1099
9715	Doczom	1100	stdcall fix_coff_symbols, edx, [esi + DLLDESCR.symbols_ptr], eax, \
2288	clevermous	1101	ecx, 0
		1102	; test eax, eax
		1103	; jnz @F
		1104	;
		1105	;@@:
		1106
9715	Doczom	1107	stdcall get_coff_sym, [esi + DLLDESCR.symbols_ptr], [ebx + COFF_HEADER.nSymbols], szEXPORTS
2288	clevermous	1108	test eax, eax
		1109	jnz @F
		1110
9715	Doczom	1111	stdcall get_coff_sym, [esi + DLLDESCR.symbols_ptr], [ebx + COFF_HEADER.nSymbols], sz_EXPORTS
2288	clevermous	1112	@@:
9715	Doczom	1113	mov [esi + DLLDESCR.exports], eax
2288	clevermous	1114
		1115	; fix relocs in the hidden copy in kernel memory to default address
		1116	; it is first fix; usually this will be enough, but second fix
		1117	; can be necessary if real load address will not equal assumption
9715	Doczom	1118	mov eax, [esi + DLLDESCR.data]
		1119	sub eax, [esi + DLLDESCR.defaultbase]
		1120	stdcall fix_coff_relocs, ebx, [esi + DLLDESCR.symbols_ptr], eax
2288	clevermous	1121
		1122	stdcall kernel_free, [coff]
		1123
3827	clevermous	1124	cli
		1125	; initialize DLLDESCR struct
9715	Doczom	1126	and dword [esi + DLLDESCR.refcount], 0; no HDLLs yet; later it will be incremented
		1127	mov [esi + DLLDESCR.fd], dll_list
3827	clevermous	1128	mov eax, [dll_list.bk]
		1129	mov [dll_list.bk], esi
9715	Doczom	1130	mov [esi + DLLDESCR.bk], eax
		1131	mov [eax + DLLDESCR.fd], esi
2288	clevermous	1132	.dll_already_loaded:
6502	pathoswith	1133	stdcall kernel_free, [fullname]
9715	Doczom	1134	inc [esi + DLLDESCR.refcount]
2288	clevermous	1135	push esi
		1136	call init_heap
		1137	pop esi
9715	Doczom	1138	mov edi, [esi + DLLDESCR.size]
		1139	stdcall user_alloc_at, [esi + DLLDESCR.defaultbase], edi
2288	clevermous	1140	test eax, eax
		1141	jnz @f
		1142	stdcall user_alloc, edi
		1143	test eax, eax
		1144	jz .fail_and_dereference
		1145	@@:
		1146	mov [img_base], eax
2384	hidnplayr	1147	mov eax, sizeof.HDLL
2288	clevermous	1148	call malloc
		1149	test eax, eax
		1150	jz .fail_and_free_user
9828	Doczom	1151	mov ebx, [current_slot]
		1152	mov edx, [ebx + APPDATA.tid]
9715	Doczom	1153	mov [eax + HDLL.pid], edx
2288	clevermous	1154	push eax
		1155	call init_dlls_in_thread
		1156	pop ebx
		1157	test eax, eax
		1158	jz .fail_and_free_user
9715	Doczom	1159	mov edx, [eax + HDLL.fd]
		1160	mov [ebx + HDLL.fd], edx
		1161	mov [ebx + HDLL.bk], eax
		1162	mov [eax + HDLL.fd], ebx
		1163	mov [edx + HDLL.bk], ebx
2288	clevermous	1164	mov eax, ebx
		1165	mov ebx, [img_base]
9715	Doczom	1166	mov [eax + HDLL.base], ebx
		1167	mov [eax + HDLL.size], edi
		1168	mov [eax + HDLL.refcount], 1
		1169	mov [eax + HDLL.parent], esi
2288	clevermous	1170	mov edx, ebx
		1171	shr edx, 12
9715	Doczom	1172	or dword [page_tabs + (edx-1)*4], MEM_BLOCK_DONT_FREE
2288	clevermous	1173	; copy entries of page table from kernel-side image to usermode
		1174	; use copy-on-write for user-mode image, so map as readonly
		1175	xor edi, edi
9715	Doczom	1176	mov ecx, [esi + DLLDESCR.data]
2288	clevermous	1177	shr ecx, 12
		1178	.map_pages_loop:
9715	Doczom	1179	mov eax, [page_tabs + ecx*4]
9823	dunkaist	1180	and eax, -PAGE_SIZE
5356	serge	1181	or al, PG_UR
9715	Doczom	1182	xchg eax, [page_tabs + edx*4]
2288	clevermous	1183	test al, 1
		1184	jz @f
		1185	call free_page
		1186	@@:
		1187	invlpg [ebx+edi]
		1188	inc ecx
		1189	inc edx
9823	dunkaist	1190	add edi, PAGE_SIZE
9715	Doczom	1191	cmp edi, [esi + DLLDESCR.size]
2288	clevermous	1192	jb .map_pages_loop
		1193
		1194	; if real user-mode base is not equal to preferred base, relocate image
9715	Doczom	1195	sub ebx, [esi + DLLDESCR.defaultbase]
2288	clevermous	1196	jz @f
9715	Doczom	1197	stdcall rebase_coff, [esi + DLLDESCR.coff_hdr], [esi + DLLDESCR.symbols_ptr], ebx
2288	clevermous	1198	@@:
		1199
9715	Doczom	1200	mov eax, [esi + DLLDESCR.exports]
		1201	sub eax, [esi + DLLDESCR.defaultbase]
2288	clevermous	1202	add eax, [img_base]
3827	clevermous	1203	sti
2288	clevermous	1204	ret
6502	pathoswith	1205
2288	clevermous	1206	.fail_and_free_data:
9715	Doczom	1207	stdcall kernel_free, [esi + DLLDESCR.data]
2288	clevermous	1208	.fail_and_free_dll:
		1209	mov eax, esi
		1210	call free
		1211	.fail_and_free_coff:
		1212	stdcall kernel_free, [coff]
		1213	.fail:
6502	pathoswith	1214	stdcall kernel_free, [fullname]
2288	clevermous	1215	xor eax, eax
		1216	ret
6502	pathoswith	1217
2288	clevermous	1218	.fail_and_free_user:
		1219	stdcall user_free, [img_base]
		1220	.fail_and_dereference:
		1221	mov eax, 1 ; delete 1 reference
		1222	call dereference_dll
3827	clevermous	1223	sti
2288	clevermous	1224	xor eax, eax
		1225	ret
		1226	endp
		1227
		1228	; initialize [APPDATA.dlls_list_ptr] for given thread
		1229	; DLL is per-process object, so APPDATA.dlls_list_ptr must be
		1230	; kept in sync for all threads of one process.
		1231	; out: eax = APPDATA.dlls_list_ptr if all is OK,
		1232	; NULL if memory allocation failed
		1233	init_dlls_in_thread:
5130	serge	1234	mov ebx, [current_process]
9715	Doczom	1235	mov eax, [ebx + PROC.dlls_list_ptr]
2288	clevermous	1236	test eax, eax
		1237	jnz .ret
5130	serge	1238
2288	clevermous	1239	mov eax, 8
5130	serge	1240	call malloc ; FIXME
2288	clevermous	1241	test eax, eax
		1242	jz .ret
5130	serge	1243
2288	clevermous	1244	mov [eax], eax
		1245	mov [eax+4], eax
5130	serge	1246
		1247	mov ebx, [current_process]
9715	Doczom	1248	mov [ebx + PROC.dlls_list_ptr], eax
2288	clevermous	1249	.ret:
		1250	ret
		1251
		1252	; in: eax = number of references to delete, esi -> DLLDESCR struc
		1253	dereference_dll:
9715	Doczom	1254	sub [esi + DLLDESCR.refcount], eax
2288	clevermous	1255	jnz .ret
9715	Doczom	1256	mov eax, [esi + DLLDESCR.fd]
		1257	mov edx, [esi + DLLDESCR.bk]
		1258	mov [eax + DLLDESCR.bk], edx
		1259	mov [edx + DLLDESCR.fd], eax
		1260	stdcall kernel_free, [esi + DLLDESCR.coff_hdr]
		1261	stdcall kernel_free, [esi + DLLDESCR.data]
2288	clevermous	1262	mov eax, esi
		1263	call free
		1264	.ret:
		1265	ret
		1266
		1267	destroy_hdll:
		1268	push ebx ecx esi edi
9715	Doczom	1269	mov ebx, [eax + HDLL.base]
		1270	mov esi, [eax + HDLL.parent]
		1271	mov edx, [esi + DLLDESCR.size]
5130	serge	1272
2288	clevermous	1273	push eax
9715	Doczom	1274	mov esi, [eax + HDLL.parent]
		1275	mov eax, [eax + HDLL.refcount]
2288	clevermous	1276	call dereference_dll
		1277	pop eax
9715	Doczom	1278	mov edx, [eax + HDLL.bk]
		1279	mov ebx, [eax + HDLL.fd]
		1280	mov [ebx + HDLL.bk], edx
		1281	mov [edx + HDLL.fd], ebx
2288	clevermous	1282	call free
		1283	pop edi esi ecx ebx
		1284	ret
		1285
		1286	; ecx -> APPDATA for slot, esi = dlls_list_ptr
		1287	destroy_all_hdlls:
		1288	test esi, esi
		1289	jz .ret
		1290	.loop:
9715	Doczom	1291	mov eax, [esi + HDLL.fd]
2288	clevermous	1292	cmp eax, esi
		1293	jz free
		1294	call destroy_hdll
		1295	jmp .loop
		1296	.ret:
		1297	ret
		1298
		1299	; param
		1300	; eax= size
		1301	; ebx= pid
		1302
		1303	align 4
		1304	create_kernel_object:
		1305
		1306	push ebx
		1307	call malloc
		1308	pop ebx
		1309	test eax, eax
		1310	jz .fail
		1311
		1312	mov ecx, [current_slot]
		1313	add ecx, APP_OBJ_OFFSET
		1314
		1315	pushfd
		1316	cli
9715	Doczom	1317	mov edx, [ecx + APPOBJ.fd]
		1318	mov [eax + APPOBJ.fd], edx
		1319	mov [eax + APPOBJ.bk], ecx
		1320	mov [eax + APPOBJ.pid], ebx
2288	clevermous	1321
9715	Doczom	1322	mov [ecx + APPOBJ.fd], eax
		1323	mov [edx + APPOBJ.bk], eax
2288	clevermous	1324	popfd
		1325	.fail:
		1326	ret
		1327
		1328	; param
		1329	; eax= object
		1330
		1331	align 4
		1332	destroy_kernel_object:
		1333
		1334	pushfd
		1335	cli
9715	Doczom	1336	mov ebx, [eax + APPOBJ.fd]
		1337	mov ecx, [eax + APPOBJ.bk]
		1338	mov [ebx + APPOBJ.bk], ecx
		1339	mov [ecx + APPOBJ.fd], ebx
2288	clevermous	1340	popfd
		1341
		1342	xor edx, edx ;clear common header
		1343	mov [eax], edx
		1344	mov [eax+4], edx
		1345	mov [eax+8], edx
		1346	mov [eax+12], edx
		1347	mov [eax+16], edx
		1348
		1349	call free ;release object memory
		1350	ret
5595	serge	1351
6926	serge	1352
		1353	;void* __fastcall create_object(size_t size)
5595	serge	1354	; param
		1355	; ecx= size
		1356
		1357	align 4
		1358	create_object:
		1359
		1360	push esi
		1361	push edi
		1362	pushfd
		1363	cli
		1364
		1365	mov esi, [current_process]
9715	Doczom	1366	mov eax, [esi + PROC.ht_free]
		1367	mov edi, [esi + PROC.ht_next]
5595	serge	1368	dec eax
		1369	js .err0
		1370
9715	Doczom	1371	mov [esi + PROC.ht_free], eax
		1372	mov eax, [esi + PROC.htab + edi*4]
		1373	mov [esi + PROC.ht_next], eax
5595	serge	1374	popfd
		1375
		1376	mov eax, ecx
		1377	call malloc
		1378	test eax, eax
		1379	jz .err1
		1380
9715	Doczom	1381	mov [eax + FUTEX.handle], edi
		1382	mov [esi + PROC.htab+edi*4], eax
5595	serge	1383	pop edi
		1384	pop esi
		1385	ret
		1386
		1387	.err1:
		1388	pushfd
		1389	cli
		1390
9715	Doczom	1391	mov eax, [esi + PROC.ht_next]
		1392	mov [esi + PROC.htab+edi*4], eax
		1393	mov [esi + PROC.ht_next], edi
		1394	inc [esi + PROC.ht_free]
5595	serge	1395	.err0:
		1396	popfd
		1397	pop edi
		1398	pop esi
		1399	xor eax, eax
		1400	ret
		1401
6926	serge	1402
		1403	;int __fastcall destroy_object(struct object *obj)
		1404
		1405	align 4
		1406	destroy_object:
		1407	push esi
		1408	mov esi, [current_process]
9715	Doczom	1409	mov edx, [ecx + FUTEX.handle]
6926	serge	1410
		1411	pushfd
		1412	cli
		1413
9715	Doczom	1414	mov eax, [esi + PROC.ht_next]
		1415	mov [esi + PROC.htab + edx*4], eax
		1416	mov [esi + PROC.ht_next], edx
		1417	inc [esi + PROC.ht_free]
6926	serge	1418
		1419	popfd
		1420	pop esi
		1421
		1422	mov eax, ecx
		1423	call free
		1424	xor eax, eax
		1425	ret
		1426	.fail:
		1427	popfd
		1428	pop esi
		1429	mov eax, -1
		1430	ret
		1431

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/dll.inc @ 429 – Rev 9976