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

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/dll.inc @ 2501 – Rev 3296