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

Rev	Author	Line No.	Line
431	serge	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
		2	;; ;;
2465	Serge	3	;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;;
431	serge	4	;; Distributed under terms of the GNU General Public License ;;
		5	;; ;;
		6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
164	serge	7
593	mikedld	8	$Revision: 3500 $
		9
		10
465	serge	11	DRV_COMPAT equ 5 ;minimal required drivers version
2106	serge	12	DRV_CURRENT equ 6 ;current drivers model version
214	serge	13
227	serge	14	DRV_VERSION equ (DRV_COMPAT shl 16) or DRV_CURRENT
797	serge	15	PID_KERNEL equ 1 ;os_idle thread
227	serge	16
164	serge	17
774	Rus	18
164	serge	19	align 4
		20	proc get_notify stdcall, p_ev:dword
		21
		22	.wait:
2434	Serge	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
164	serge	32	@@:
2434	Serge	33	call change_task
		34	jmp .wait
164	serge	35	endp
		36
		37	align 4
		38	proc pci_read32 stdcall, bus:dword, devfn:dword, reg:dword
2434	Serge	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
164	serge	49	endp
		50
		51	align 4
557	serge	52	proc pci_read16 stdcall, bus:dword, devfn:dword, reg:dword
2434	Serge	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
557	serge	63	endp
		64
		65	align 4
164	serge	66	proc pci_read8 stdcall, bus:dword, devfn:dword, reg:dword
2434	Serge	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
164	serge	77	endp
		78
		79	align 4
		80	proc pci_write8 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
2434	Serge	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
164	serge	92	endp
		93
557	serge	94	align 4
		95	proc pci_write16 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
2434	Serge	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
557	serge	107	endp
		108
672	hidnplayr	109	align 4
		110	proc pci_write32 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
2434	Serge	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
672	hidnplayr	122	endp
164	serge	123
2434	Serge	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
164	serge	130
672	hidnplayr	131
164	serge	132	align 4
		133	proc srv_handler stdcall, ioctl:dword
2434	Serge	134	mov esi, [ioctl]
		135	test esi, esi
		136	jz .err
164	serge	137
2434	Serge	138	mov edi, [esi+handle]
		139	cmp [edi+SRV.magic], ' SRV'
		140	jne .fail
164	serge	141
2434	Serge	142	cmp [edi+SRV.size], sizeof.SRV
		143	jne .fail
164	serge	144
2434	Serge	145	stdcall [edi+SRV.srv_proc], esi
		146	ret
164	serge	147	.fail:
2434	Serge	148	xor eax, eax
		149	not eax
		150	mov [esi+output], eax
		151	mov [esi+out_size], 4
		152	ret
164	serge	153	.err:
2434	Serge	154	xor eax, eax
		155	not eax
		156	ret
164	serge	157	endp
		158
377	serge	159	; param
1345	Lrz	160	; ecx= io_control
377	serge	161	;
		162	; retval
		163	; eax= error code
		164
164	serge	165	align 4
377	serge	166	srv_handlerEx:
2434	Serge	167	cmp ecx, OS_BASE
		168	jae .fail
164	serge	169
2434	Serge	170	mov eax, [ecx+handle]
		171	cmp [eax+SRV.magic], ' SRV'
		172	jne .fail
164	serge	173
2434	Serge	174	cmp [eax+SRV.size], sizeof.SRV
		175	jne .fail
164	serge	176
2434	Serge	177	stdcall [eax+SRV.srv_proc], ecx
		178	ret
164	serge	179	.fail:
2434	Serge	180	or eax, -1
		181	ret
164	serge	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
2434	Serge	192	mov eax, [sz_name]
		193	test eax, eax
		194	jnz @F
		195	ret
164	serge	196	@@:
2434	Serge	197	mov edx, [srv.fd]
188	serge	198	@@:
2434	Serge	199	cmp edx, srv.fd-SRV.fd
		200	je .not_load
278	serge	201
2434	Serge	202	stdcall strncmp, edx, [sz_name], 16
		203	test eax, eax
		204	je .ok
164	serge	205
2434	Serge	206	mov edx, [edx+SRV.fd]
		207	jmp @B
164	serge	208	.not_load:
2434	Serge	209	pop ebp
		210	jmp load_driver
164	serge	211	.ok:
2434	Serge	212	mov eax, edx
		213	ret
164	serge	214	endp
		215
		216	align 4
740	serge	217	proc reg_service stdcall, name:dword, handler:dword
164	serge	218
2434	Serge	219	push ebx
164	serge	220
2434	Serge	221	xor eax, eax
819	serge	222
2434	Serge	223	cmp [name], eax
		224	je .fail
740	serge	225
2434	Serge	226	cmp [handler], eax
		227	je .fail
740	serge	228
2434	Serge	229	mov eax, sizeof.SRV
		230	call malloc
		231	test eax, eax
		232	jz .fail
164	serge	233
2434	Serge	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
164	serge	244
2434	Serge	245	mov [eax+SRV.magic], ' SRV'
		246	mov [eax+SRV.size], sizeof.SRV
278	serge	247
2434	Serge	248	mov ebx, srv.fd-SRV.fd
		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
278	serge	254
2434	Serge	255	mov ecx, [handler]
		256	mov [eax+SRV.srv_proc], ecx
		257	pop ebx
		258	ret
164	serge	259	.fail:
2434	Serge	260	xor eax, eax
		261	pop ebx
		262	ret
740	serge	263	endp
164	serge	264
		265	align 4
		266	proc get_proc stdcall, exp:dword, sz_name:dword
		267
2434	Serge	268	mov edx, [exp]
164	serge	269	.next:
2434	Serge	270	mov eax, [edx]
		271	test eax, eax
		272	jz .end
164	serge	273
2434	Serge	274	push edx
		275	stdcall strncmp, eax, [sz_name], 16
		276	pop edx
		277	test eax, eax
		278	jz .ok
164	serge	279
2434	Serge	280	add edx, 8
		281	jmp .next
164	serge	282	.ok:
2434	Serge	283	mov eax, [edx+4]
164	serge	284	.end:
2434	Serge	285	ret
164	serge	286	endp
		287
		288	align 4
		289	proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword
		290
		291	@@:
2434	Serge	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
164	serge	300	.ok:
2434	Serge	301	mov eax, [pSym]
		302	mov eax, [eax+8]
		303	ret
164	serge	304	endp
		305
		306	align 4
188	serge	307	proc get_curr_task
2434	Serge	308	mov eax, [CURRENT_TASK]
		309	shl eax, 8
		310	ret
188	serge	311	endp
164	serge	312
188	serge	313	align 4
		314	proc get_fileinfo stdcall, file_name:dword, info:dword
2434	Serge	315	locals
		316	cmd dd ?
		317	offset dd ?
		318	dd ?
		319	count dd ?
		320	buff dd ?
		321	db ?
		322	name dd ?
		323	endl
164	serge	324
2434	Serge	325	xor eax, eax
		326	mov ebx, [file_name]
		327	mov ecx, [info]
164	serge	328
2434	Serge	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
164	serge	336
2434	Serge	337	mov eax, 70
		338	lea ebx, [cmd]
		339	int 0x40
		340	ret
188	serge	341	endp
164	serge	342
188	serge	343	align 4
		344	proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\
2434	Serge	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
164	serge	355
2434	Serge	356	xor eax, eax
		357	mov ebx, [file_name]
		358	mov ecx, [off]
		359	mov edx, [bytes]
		360	mov esi, [buffer]
164	serge	361
2434	Serge	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
188	serge	369
2434	Serge	370	pushad
		371	lea ebx, [cmd]
3500	Serge	372	call file_system_lfn_protected
2434	Serge	373	popad
		374	ret
188	serge	375	endp
		376
363	serge	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
188	serge	391	align 4
		392	proc load_file stdcall, file_name:dword
2434	Serge	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 ?
188	serge	403
2434	Serge	404	file dd ?
		405	file2 dd ?
		406	endl
188	serge	407
2434	Serge	408	push esi
		409	push edi
662	serge	410
2434	Serge	411	lea eax, [attr]
		412	stdcall get_fileinfo, [file_name], eax
		413	test eax, eax
		414	jnz .fail
164	serge	415
2434	Serge	416	mov eax, [file_size]
		417	cmp eax, 1024102416
		418	ja .fail
206	serge	419
2434	Serge	420	stdcall kernel_alloc, [file_size]
		421	mov [file], eax
		422	test eax, eax
		423	jz .fail
164	serge	424
2434	Serge	425	stdcall read_file, [file_name], eax, dword 0, [file_size]
		426	cmp ebx, [file_size]
		427	jne .cleanup
211	serge	428
2434	Serge	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
211	serge	435
2434	Serge	436	test eax, eax
		437	jz .cleanup
211	serge	438
2434	Serge	439	mov [file2], eax
2987	Serge	440
		441	pushad
		442	mov ecx, unpack_mutex
		443	call mutex_lock
		444	popad
		445
2434	Serge	446	stdcall unpack, [file], eax
2987	Serge	447
		448	pushad
		449	mov ecx, unpack_mutex
		450	call mutex_unlock
		451	popad
		452
2434	Serge	453	stdcall kernel_free, [file]
		454	mov eax, [file2]
		455	mov ebx, [file_size]
211	serge	456	.exit:
2434	Serge	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
521	diamond	466	@@:
2434	Serge	467	mov ebx, [file_size]
		468	pop eax
		469	pop edi
		470	pop esi
		471	ret
188	serge	472	.cleanup:
2434	Serge	473	stdcall kernel_free, [file]
188	serge	474	.fail:
2434	Serge	475	xor eax, eax
		476	xor ebx, ebx
		477	pop edi
		478	pop esi
		479	ret
188	serge	480	endp
164	serge	481
2987	Serge	482	uglobal
188	serge	483	align 4
2987	Serge	484	unpack_mutex MUTEX
		485	endg
		486
		487	align 4
188	serge	488	proc get_proc_ex stdcall, proc_name:dword, imports:dword
		489
		490	.look_up:
2434	Serge	491	mov edx, [imports]
		492	test edx, edx
		493	jz .end
		494	mov edx, [edx]
		495	test edx, edx
		496	jz .end
188	serge	497	.next:
2434	Serge	498	mov eax, [edx]
		499	test eax, eax
		500	jz .next_table
164	serge	501
2434	Serge	502	push edx
		503	stdcall strncmp, eax, [proc_name], 256
		504	pop edx
		505	test eax, eax
		506	jz .ok
164	serge	507
2434	Serge	508	add edx, 8
		509	jmp .next
188	serge	510	.next_table:
2434	Serge	511	add [imports], 4
		512	jmp .look_up
188	serge	513	.ok:
2434	Serge	514	mov eax, [edx+4]
		515	ret
188	serge	516	.end:
2434	Serge	517	xor eax, eax
		518	ret
188	serge	519	endp
164	serge	520
188	serge	521	align 4
1289	diamond	522	proc fix_coff_symbols stdcall uses ebx esi, sec:dword, symbols:dword,\
2434	Serge	523	sym_count:dword, strings:dword, imports:dword
		524	locals
		525	retval dd ?
		526	endl
164	serge	527
2434	Serge	528	mov edi, [symbols]
		529	mov [retval], 1
188	serge	530	.fix:
2434	Serge	531	movzx ebx, [edi+COFF_SYM.SectionNumber]
		532	test ebx, ebx
		533	jnz .internal
		534	mov eax, dword [edi+COFF_SYM.Name]
		535	test eax, eax
		536	jnz @F
164	serge	537
2434	Serge	538	mov edi, [edi+4]
		539	add edi, [strings]
188	serge	540	@@:
2434	Serge	541	push edi
		542	stdcall get_proc_ex, edi, [imports]
		543	pop edi
164	serge	544
2434	Serge	545	xor ebx, ebx
		546	test eax, eax
		547	jnz @F
164	serge	548
2434	Serge	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
164	serge	555
2434	Serge	556	mov [retval], 0
188	serge	557	@@:
2434	Serge	558	mov edi, [symbols]
		559	mov [edi+COFF_SYM.Value], eax
		560	jmp .next
188	serge	561	.internal:
2434	Serge	562	cmp bx, -1
		563	je .next
		564	cmp bx, -2
		565	je .next
541	serge	566
2434	Serge	567	dec ebx
		568	shl ebx, 3
		569	lea ebx, [ebx+ebx*4]
		570	add ebx, [sec]
188	serge	571
2434	Serge	572	mov eax, [ebx+COFF_SECTION.VirtualAddress]
		573	add [edi+COFF_SYM.Value], eax
188	serge	574	.next:
2434	Serge	575	add edi, sizeof.COFF_SYM
		576	mov [symbols], edi
		577	dec [sym_count]
		578	jnz .fix
		579	mov eax, [retval]
		580	ret
164	serge	581	endp
		582
		583	align 4
1289	diamond	584	proc fix_coff_relocs stdcall uses ebx esi, coff:dword, sym:dword, \
2434	Serge	585	delta:dword
		586	locals
		587	n_sec dd ?
		588	endl
164	serge	589
2434	Serge	590	mov eax, [coff]
		591	movzx ebx, [eax+COFF_HEADER.nSections]
		592	mov [n_sec], ebx
		593	lea esi, [eax+20]
188	serge	594	.fix_sec:
2434	Serge	595	mov edi, [esi+COFF_SECTION.PtrReloc]
		596	add edi, [coff]
164	serge	597
2434	Serge	598	movzx ecx, [esi+COFF_SECTION.NumReloc]
		599	test ecx, ecx
		600	jz .next
1289	diamond	601	.reloc_loop:
2434	Serge	602	mov ebx, [edi+COFF_RELOC.SymIndex]
		603	add ebx, ebx
		604	lea ebx, [ebx+ebx*8]
		605	add ebx, [sym]
164	serge	606
2434	Serge	607	mov edx, [ebx+COFF_SYM.Value]
164	serge	608
2434	Serge	609	cmp [edi+COFF_RELOC.Type], 6
		610	je .dir_32
164	serge	611
2434	Serge	612	cmp [edi+COFF_RELOC.Type], 20
		613	jne .next_reloc
188	serge	614	.rel_32:
2434	Serge	615	mov eax, [edi+COFF_RELOC.VirtualAddress]
		616	add eax, [esi+COFF_SECTION.VirtualAddress]
		617	sub edx, eax
		618	sub edx, 4
		619	jmp .fix
188	serge	620	.dir_32:
2434	Serge	621	mov eax, [edi+COFF_RELOC.VirtualAddress]
		622	add eax, [esi+COFF_SECTION.VirtualAddress]
188	serge	623	.fix:
2434	Serge	624	add eax, [delta]
		625	add [eax], edx
1289	diamond	626	.next_reloc:
2434	Serge	627	add edi, 10
		628	dec ecx
		629	jnz .reloc_loop
188	serge	630	.next:
2434	Serge	631	add esi, sizeof.COFF_SECTION
		632	dec [n_sec]
		633	jnz .fix_sec
164	serge	634	.exit:
2434	Serge	635	ret
164	serge	636	endp
		637
2106	serge	638	align 4
1289	diamond	639	proc rebase_coff stdcall uses ebx esi, coff:dword, sym:dword, \
2434	Serge	640	delta:dword
		641	locals
		642	n_sec dd ?
		643	endl
1289	diamond	644
2434	Serge	645	mov eax, [coff]
		646	movzx ebx, [eax+COFF_HEADER.nSections]
		647	mov [n_sec], ebx
		648	lea esi, [eax+20]
		649	mov edx, [delta]
1289	diamond	650	.fix_sec:
2434	Serge	651	mov edi, [esi+COFF_SECTION.PtrReloc]
		652	add edi, [coff]
1289	diamond	653
2434	Serge	654	movzx ecx, [esi+COFF_SECTION.NumReloc]
		655	test ecx, ecx
		656	jz .next
1289	diamond	657	.reloc_loop:
2434	Serge	658	cmp [edi+COFF_RELOC.Type], 6
		659	jne .next_reloc
1289	diamond	660	.dir_32:
2434	Serge	661	mov eax, [edi+COFF_RELOC.VirtualAddress]
		662	add eax, [esi+COFF_SECTION.VirtualAddress]
		663	add [eax+edx], edx
1289	diamond	664	.next_reloc:
2434	Serge	665	add edi, 10
		666	dec ecx
		667	jnz .reloc_loop
1289	diamond	668	.next:
2434	Serge	669	add esi, sizeof.COFF_SECTION
		670	dec [n_sec]
		671	jnz .fix_sec
1289	diamond	672	.exit:
2434	Serge	673	ret
1289	diamond	674	endp
		675
188	serge	676	align 4
346	diamond	677	proc load_driver stdcall, driver_name:dword
2434	Serge	678	locals
		679	coff dd ?
		680	sym dd ?
		681	strings dd ?
		682	img_size dd ?
		683	img_base dd ?
		684	start dd ?
188	serge	685
2434	Serge	686	exports dd ? ;fake exports table
		687	dd ?
		688	file_name rb 13+16+4+1 ; '/sys/drivers/.obj'
		689	endl
188	serge	690
2434	Serge	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]
1018	diamond	697	.redo:
2434	Serge	698	lea edx, [file_name]
		699	lea edi, [edx+13]
		700	mov ecx, 16
346	diamond	701	@@:
2434	Serge	702	lodsb
		703	test al, al
		704	jz @f
		705	stosb
		706	loop @b
346	diamond	707	@@:
2434	Serge	708	mov dword [edi], '.obj'
		709	mov byte [edi+4], 0
		710	stdcall load_file, edx
214	serge	711
2434	Serge	712	test eax, eax
		713	jz .exit
188	serge	714
2434	Serge	715	mov [coff], eax
188	serge	716
2434	Serge	717	movzx ecx, [eax+COFF_HEADER.nSections]
		718	xor ebx, ebx
188	serge	719
2434	Serge	720	lea edx, [eax+20]
188	serge	721	@@:
2434	Serge	722	add ebx, [edx+COFF_SECTION.SizeOfRawData]
		723	add ebx, 15
		724	and ebx, not 15
		725	add edx, sizeof.COFF_SECTION
		726	dec ecx
		727	jnz @B
		728	mov [img_size], ebx
188	serge	729
2434	Serge	730	stdcall kernel_alloc, ebx
		731	test eax, eax
		732	jz .fail
		733	mov [img_base], eax
188	serge	734
2434	Serge	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
188	serge	743
2434	Serge	744	mov edx, [coff]
		745	movzx ebx, [edx+COFF_HEADER.nSections]
		746	mov edi, [img_base]
		747	lea eax, [edx+20]
188	serge	748	@@:
2434	Serge	749	mov [eax+COFF_SECTION.VirtualAddress], edi
		750	mov esi, [eax+COFF_SECTION.PtrRawData]
		751	test esi, esi
		752	jnz .copy
		753	add edi, [eax+COFF_SECTION.SizeOfRawData]
		754	jmp .next
188	serge	755	.copy:
2434	Serge	756	add esi, edx
		757	mov ecx, [eax+COFF_SECTION.SizeOfRawData]
		758	cld
		759	rep movsb
188	serge	760	.next:
2434	Serge	761	add edi, 15
		762	and edi, not 15
		763	add eax, sizeof.COFF_SECTION
		764	dec ebx
		765	jnz @B
188	serge	766
2434	Serge	767	mov ebx, [edx+COFF_HEADER.pSymTable]
		768	add ebx, edx
		769	mov [sym], ebx
		770	mov ecx, [edx+COFF_HEADER.nSymbols]
		771	add ecx, ecx
		772	lea ecx, [ecx+ecx8];ecx=18 = nSymbols*CSYM_SIZE
		773	add ecx, [sym]
		774	mov [strings], ecx
188	serge	775
2434	Serge	776	lea ebx, [exports]
		777	mov dword [ebx], kernel_export
		778	mov dword [ebx+4], 0
		779	lea eax, [edx+20]
188	serge	780
2434	Serge	781	stdcall fix_coff_symbols, eax, [sym], [edx+COFF_HEADER.nSymbols], \
		782	[strings], ebx
		783	test eax, eax
		784	jz .link_fail
188	serge	785
2434	Serge	786	mov ebx, [coff]
		787	stdcall fix_coff_relocs, ebx, [sym], 0
188	serge	788
2434	Serge	789	stdcall get_coff_sym, [sym], [ebx+COFF_HEADER.nSymbols], szVersion
		790	test eax, eax
		791	jz .link_fail
227	serge	792
2434	Serge	793	mov eax, [eax]
		794	shr eax, 16
		795	cmp eax, DRV_COMPAT
		796	jb .ver_fail
227	serge	797
2434	Serge	798	cmp eax, DRV_CURRENT
		799	ja .ver_fail
227	serge	800
2434	Serge	801	mov ebx, [coff]
		802	stdcall get_coff_sym, [sym], [ebx+COFF_HEADER.nSymbols], szSTART
		803	mov [start], eax
188	serge	804
2434	Serge	805	stdcall kernel_free, [coff]
188	serge	806
2434	Serge	807	mov ebx, [start]
		808	stdcall ebx, DRV_ENTRY
		809	test eax, eax
		810	jnz .ok
188	serge	811
2434	Serge	812	stdcall kernel_free, [img_base]
3232	Serge	813
2434	Serge	814	xor eax, eax
		815	ret
188	serge	816	.ok:
2434	Serge	817	mov ebx, [img_base]
		818	mov [eax+SRV.base], ebx
		819	mov ecx, [start]
		820	mov [eax+SRV.entry], ecx
		821	ret
227	serge	822
		823	.ver_fail:
2434	Serge	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
227	serge	835
		836	.link_fail:
2434	Serge	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
227	serge	843	.cleanup:
2434	Serge	844	stdcall kernel_free, [img_base]
188	serge	845	.fail:
2434	Serge	846	stdcall kernel_free, [coff]
227	serge	847	.exit:
2434	Serge	848	xor eax, eax
		849	ret
164	serge	850	endp
		851
1296	diamond	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.
2434	Serge	859	push ecx
		860	mov cl, byte [edx+COFF_SECTION.Characteristics+2]
		861	mov eax, 1
		862	shr cl, 4
		863	dec cl
		864	js .default
		865	cmp cl, 12
		866	jbe @f
1296	diamond	867	.default:
2434	Serge	868	mov cl, 12
1296	diamond	869	@@:
2434	Serge	870	shl eax, cl
		871	pop ecx
		872	dec eax
		873	ret
1296	diamond	874
198	serge	875	align 4
		876	proc load_library stdcall, file_name:dword
2434	Serge	877	locals
		878	fullname rb 260
		879	fileinfo rb 40
		880	coff dd ?
		881	img_base dd ?
		882	endl
198	serge	883
2434	Serge	884	cli
198	serge	885
1289	diamond	886	; resolve file name
2434	Serge	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
1289	diamond	893
		894	; scan for required DLL in list of already loaded for this process,
		895	; ignore timestamp
2434	Serge	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]
1289	diamond	903	.scan_in_process:
2434	Serge	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
1289	diamond	911	; simple variant: load DLL which is already loaded in this process
		912	; just increment reference counters and return address of exports table
2434	Serge	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
1289	diamond	920	.next_in_process:
2434	Serge	921	mov esi, [esi+HDLL.fd]
		922	jmp .scan_in_process
1289	diamond	923	.not_in_process:
		924
		925	; scan in full list, compare timestamp
2434	Serge	926	lea eax, [fileinfo]
		927	stdcall get_fileinfo, edi, eax
		928	test eax, eax
		929	jnz .fail
		930	mov esi, [dll_list.fd]
1289	diamond	931	.scan_for_dlls:
2434	Serge	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
1289	diamond	938	.test_prev_dll:
2434	Serge	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
1289	diamond	945	.continue_scan:
2434	Serge	946	mov esi, [esi+DLLDESCR.fd]
		947	jmp .scan_for_dlls
1289	diamond	948
		949	; new DLL
		950	.load_new:
		951	; load file
2434	Serge	952	stdcall load_file, edi
		953	test eax, eax
		954	jz .fail
		955	mov [coff], eax
		956	mov dword [fileinfo+32], ebx
198	serge	957
1289	diamond	958	; allocate DLLDESCR struct; size is DLLDESCR.sizeof plus size of DLL name
2434	Serge	959	mov esi, edi
		960	mov ecx, -1
		961	xor eax, eax
		962	repnz scasb
		963	not ecx
		964	lea eax, [ecx+sizeof.DLLDESCR]
		965	push ecx
		966	call malloc
		967	pop ecx
		968	test eax, eax
		969	jz .fail_and_free_coff
1289	diamond	970	; save timestamp
2434	Serge	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
1289	diamond	978	; initialize DLLDESCR struct
2434	Serge	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
1289	diamond	985
		986	; calculate size of loaded DLL
2434	Serge	987	mov edx, [coff]
		988	movzx ecx, [edx+COFF_HEADER.nSections]
		989	xor ebx, ebx
198	serge	990
2434	Serge	991	add edx, 20
198	serge	992	@@:
2434	Serge	993	call coff_get_align
		994	add ebx, eax
		995	not eax
		996	and ebx, eax
		997	add ebx, [edx+COFF_SECTION.SizeOfRawData]
		998	add edx, sizeof.COFF_SECTION
		999	dec ecx
		1000	jnz @B
1289	diamond	1001	; it must be nonzero and not too big
2434	Serge	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
1289	diamond	1007	; allocate memory for kernel-side image
2434	Serge	1008	stdcall kernel_alloc, ebx
		1009	test eax, eax
		1010	jz .fail_and_free_dll
		1011	mov [esi+DLLDESCR.data], eax
1289	diamond	1012	; calculate preferred base address
2434	Serge	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]
1289	diamond	1021	@@:
2434	Serge	1022	mov [esi+DLLDESCR.defaultbase], ecx
		1023	mov [dll_cur_addr], edx
198	serge	1024
1289	diamond	1025	; copy sections and set correct values for VirtualAddress'es in headers
2434	Serge	1026	push esi
		1027	mov edx, [coff]
		1028	movzx ebx, [edx+COFF_HEADER.nSections]
		1029	mov edi, eax
		1030	add edx, 20
		1031	cld
198	serge	1032	@@:
2434	Serge	1033	call coff_get_align
		1034	add ecx, eax
		1035	add edi, eax
		1036	not eax
		1037	and ecx, eax
		1038	and edi, eax
		1039	mov [edx+COFF_SECTION.VirtualAddress], ecx
		1040	add ecx, [edx+COFF_SECTION.SizeOfRawData]
		1041	mov esi, [edx+COFF_SECTION.PtrRawData]
		1042	push ecx
		1043	mov ecx, [edx+COFF_SECTION.SizeOfRawData]
		1044	test esi, esi
		1045	jnz .copy
		1046	xor eax, eax
		1047	rep stosb
		1048	jmp .next
198	serge	1049	.copy:
2434	Serge	1050	add esi, [coff]
		1051	rep movsb
198	serge	1052	.next:
2434	Serge	1053	pop ecx
		1054	add edx, sizeof.COFF_SECTION
		1055	dec ebx
		1056	jnz @B
		1057	pop esi
198	serge	1058
1289	diamond	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
2434	Serge	1062	mov edx, [coff]
		1063	mov ebx, [edx+COFF_HEADER.pSymTable]
		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
		1069	movzx ecx, [edx+COFF_HEADER.nSections]
		1070	lea ecx, [ecx*5]
		1071	lea edi, [edi+ecx*8+20]
		1072	add edx, 20
1289	diamond	1073	@@:
2434	Serge	1074	movzx eax, [edx+COFF_SECTION.NumReloc]
		1075	lea eax, [eax*5]
		1076	lea edi, [edi+eax*2]
		1077	add edx, sizeof.COFF_SECTION
		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]
		1084	movzx ecx, [edx+COFF_HEADER.nSections]
		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
		1095	mov ecx, [edx+COFF_HEADER.nSymbols]
		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
		1103	movzx eax, [edx+COFF_HEADER.nSections]
		1104	lea edx, [ebx+20]
1289	diamond	1105	@@:
2434	Serge	1106	movzx ecx, [edx+COFF_SECTION.NumReloc]
		1107	lea ecx, [ecx*5]
		1108	mov esi, [edx+COFF_SECTION.PtrReloc]
		1109	mov [edx+COFF_SECTION.PtrReloc], edi
		1110	sub [edx+COFF_SECTION.PtrReloc], ebx
		1111	add esi, [coff]
		1112	shr ecx, 1
		1113	rep movsd
		1114	adc ecx, ecx
		1115	rep movsw
		1116	add edx, sizeof.COFF_SECTION
		1117	dec eax
		1118	jnz @b
		1119	pop esi
198	serge	1120
1289	diamond	1121	; fixup symbols
2434	Serge	1122	mov edx, ebx
		1123	mov eax, [ebx+COFF_HEADER.nSymbols]
		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]
198	serge	1129
2434	Serge	1130	stdcall fix_coff_symbols, edx, [esi+DLLDESCR.symbols_ptr], eax, \
		1131	ecx, 0
		1132	; test eax, eax
		1133	; jnz @F
1289	diamond	1134	;
		1135	;@@:
		1136
2434	Serge	1137	stdcall get_coff_sym, [esi+DLLDESCR.symbols_ptr], [ebx+COFF_HEADER.nSymbols], szEXPORTS
		1138	test eax, eax
		1139	jnz @F
198	serge	1140
2434	Serge	1141	stdcall get_coff_sym, [esi+DLLDESCR.symbols_ptr], [ebx+COFF_HEADER.nSymbols], sz_EXPORTS
198	serge	1142	@@:
2434	Serge	1143	mov [esi+DLLDESCR.exports], eax
198	serge	1144
1289	diamond	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
2434	Serge	1148	mov eax, [esi+DLLDESCR.data]
		1149	sub eax, [esi+DLLDESCR.defaultbase]
		1150	stdcall fix_coff_relocs, ebx, [esi+DLLDESCR.symbols_ptr], eax
198	serge	1151
2434	Serge	1152	stdcall kernel_free, [coff]
916	serge	1153
1289	diamond	1154	.dll_already_loaded:
2434	Serge	1155	inc [esi+DLLDESCR.refcount]
		1156	push esi
		1157	call init_heap
		1158	pop esi
1289	diamond	1159
2434	Serge	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
917	diamond	1167	@@:
2434	Serge	1168	mov [img_base], eax
		1169	mov eax, sizeof.HDLL
		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
1289	diamond	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
2434	Serge	1198	xor edi, edi
		1199	mov ecx, [esi+DLLDESCR.data]
		1200	shr ecx, 12
1289	diamond	1201	.map_pages_loop:
2434	Serge	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
1289	diamond	1209	@@:
2434	Serge	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
1289	diamond	1216
		1217	; if real user-mode base is not equal to preferred base, relocate image
2434	Serge	1218	sub ebx, [esi+DLLDESCR.defaultbase]
		1219	jz @f
		1220	stdcall rebase_coff, [esi+DLLDESCR.coff_hdr], [esi+DLLDESCR.symbols_ptr], ebx
1289	diamond	1221	@@:
		1222
2434	Serge	1223	mov eax, [esi+DLLDESCR.exports]
		1224	sub eax, [esi+DLLDESCR.defaultbase]
		1225	add eax, [img_base]
		1226	ret
1289	diamond	1227	.fail_and_free_data:
2434	Serge	1228	stdcall kernel_free, [esi+DLLDESCR.data]
1289	diamond	1229	.fail_and_free_dll:
2434	Serge	1230	mov eax, esi
		1231	call free
1289	diamond	1232	.fail_and_free_coff:
2434	Serge	1233	stdcall kernel_free, [coff]
198	serge	1234	.fail:
2434	Serge	1235	xor eax, eax
		1236	ret
1289	diamond	1237	.fail_and_free_user:
2434	Serge	1238	stdcall user_free, [img_base]
1289	diamond	1239	.fail_and_dereference:
2434	Serge	1240	mov eax, 1 ; delete 1 reference
		1241	call dereference_dll
		1242	xor eax, eax
		1243	ret
198	serge	1244	endp
		1245
1311	diamond	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:
2434	Serge	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
1311	diamond	1266	.set:
2434	Serge	1267	cmp [ebx+APPDATA.dir_table], edx
		1268	jnz @f
		1269	mov [ebx+APPDATA.dlls_list_ptr], eax
1311	diamond	1270	@@:
2434	Serge	1271	add ebx, 256
		1272	dec ecx
		1273	jnz .set
1311	diamond	1274	.ret:
2434	Serge	1275	ret
1311	diamond	1276
1289	diamond	1277	; in: eax = number of references to delete, esi -> DLLDESCR struc
		1278	dereference_dll:
2434	Serge	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	diamond	1289	.ret:
2434	Serge	1290	ret
1289	diamond	1291
		1292	destroy_hdll:
2434	Serge	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]
1292	diamond	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.
2434	Serge	1302	mov eax, [ecx+APPDATA.dir_table]
1292	diamond	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.
2434	Serge	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
1289	diamond	1319	.unmap_loop:
2434	Serge	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
1289	diamond	1329	@@:
2434	Serge	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
1292	diamond	1340	; Restore context.
2434	Serge	1341	pop eax
		1342	mov cr3, eax
		1343	pop [current_slot]
		1344	popf
1292	diamond	1345	; Ok, cheating is done.
2434	Serge	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
1289	diamond	1359
1311	diamond	1360	; ecx -> APPDATA for slot, esi = dlls_list_ptr
		1361	destroy_all_hdlls:
2434	Serge	1362	test esi, esi
		1363	jz .ret
1311	diamond	1364	.loop:
2434	Serge	1365	mov eax, [esi+HDLL.fd]
		1366	cmp eax, esi
		1367	jz free
		1368	call destroy_hdll
		1369	jmp .loop
1311	diamond	1370	.ret:
2434	Serge	1371	ret
1311	diamond	1372
214	serge	1373	align 4
1275	serge	1374	stop_all_services:
2434	Serge	1375	push ebp
		1376	mov edx, [srv.fd]
214	serge	1377	.next:
2434	Serge	1378	cmp edx, srv.fd-SRV.fd
		1379	je .done
		1380	cmp [edx+SRV.magic], ' SRV'
		1381	jne .next
		1382	cmp [edx+SRV.size], sizeof.SRV
		1383	jne .next
732	serge	1384
2434	Serge	1385	mov ebx, [edx+SRV.entry]
		1386	mov edx, [edx+SRV.fd]
		1387	test ebx, ebx
		1388	jz .next
732	serge	1389
2434	Serge	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
278	serge	1398	.done:
2434	Serge	1399	pop ebp
		1400	ret
198	serge	1401
281	serge	1402	; param
291	serge	1403	; eax= size
		1404	; ebx= pid
214	serge	1405
281	serge	1406	align 4
		1407	create_kernel_object:
		1408
2434	Serge	1409	push ebx
		1410	call malloc
		1411	pop ebx
		1412	test eax, eax
		1413	jz .fail
281	serge	1414
2434	Serge	1415	mov ecx, [current_slot]
		1416	add ecx, APP_OBJ_OFFSET
281	serge	1417
2434	Serge	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
281	serge	1424
2434	Serge	1425	mov [ecx+APPOBJ.fd], eax
		1426	mov [edx+APPOBJ.bk], eax
		1427	popfd
281	serge	1428	.fail:
2434	Serge	1429	ret
281	serge	1430
		1431	; param
		1432	; eax= object
		1433
		1434	align 4
		1435	destroy_kernel_object:
		1436
2434	Serge	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
281	serge	1444
2434	Serge	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
281	serge	1451
2434	Serge	1452	call free ;release object memory
		1453	ret

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/core/dll.inc – Rev 3500