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

Rev	Author	Line No.	Line
431	serge	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
		2	;; ;;
2540	hidnplayr	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
2540	hidnplayr	8	$Revision $
593	mikedld	9
		10
465	serge	11	DRV_COMPAT equ 5 ;minimal required drivers version
2382	hidnplayr	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
978	serge	18
164	serge	19	align 4
		20	proc get_notify stdcall, p_ev:dword
		21
		22	.wait:
2382	hidnplayr	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	@@:
2382	hidnplayr	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
2382	hidnplayr	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
2382	hidnplayr	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
2382	hidnplayr	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
2382	hidnplayr	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
2382	hidnplayr	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
2382	hidnplayr	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
2382	hidnplayr	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
2382	hidnplayr	134	mov esi, [ioctl]
		135	test esi, esi
		136	jz .err
164	serge	137
2382	hidnplayr	138	mov edi, [esi+handle]
2540	hidnplayr	139	cmp [edi+SRV.magic], ' SRV'
		140	jne .fail
		141
		142	cmp [edi+SRV.size], sizeof.SRV
		143	jne .fail
		144
		145	stdcall [edi+SRV.srv_proc], esi
2382	hidnplayr	146	ret
164	serge	147	.fail:
2382	hidnplayr	148	xor eax, eax
		149	not eax
		150	mov [esi+output], eax
		151	mov [esi+out_size], 4
		152	ret
164	serge	153	.err:
2382	hidnplayr	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:
2382	hidnplayr	167	cmp ecx, OS_BASE
		168	jae .fail
164	serge	169
2382	hidnplayr	170	mov eax, [ecx+handle]
2540	hidnplayr	171	cmp [eax+SRV.magic], ' SRV'
		172	jne .fail
		173
		174	cmp [eax+SRV.size], sizeof.SRV
		175	jne .fail
		176
		177	stdcall [eax+SRV.srv_proc], ecx
2382	hidnplayr	178	ret
164	serge	179	.fail:
2382	hidnplayr	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
2382	hidnplayr	192	mov eax, [sz_name]
		193	test eax, eax
		194	jnz @F
		195	ret
2540	hidnplayr	196	@@:
		197	mov edx, [srv.fd]
		198	@@:
		199	cmp edx, srv.fd-SRV.fd
		200	je .not_load
		201
		202	stdcall strncmp, edx, [sz_name], 16
2382	hidnplayr	203	test eax, eax
		204	je .ok
164	serge	205
2382	hidnplayr	206	mov edx, [edx+SRV.fd]
		207	jmp @B
164	serge	208	.not_load:
2382	hidnplayr	209	pop ebp
		210	jmp load_driver
164	serge	211	.ok:
2382	hidnplayr	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
2382	hidnplayr	219	push ebx
164	serge	220
2382	hidnplayr	221	xor eax, eax
819	serge	222
2382	hidnplayr	223	cmp [name], eax
		224	je .fail
740	serge	225
2540	hidnplayr	226	cmp [handler], eax
		227	je .fail
740	serge	228
2540	hidnplayr	229	mov eax, sizeof.SRV
		230	call malloc
		231	test eax, eax
		232	jz .fail
		233
2382	hidnplayr	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
2540	hidnplayr	243	pop esi
		244
		245	mov [eax+SRV.magic], ' SRV'
		246	mov [eax+SRV.size], sizeof.SRV
		247
		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
2382	hidnplayr	252	mov [ebx+SRV.fd], eax
		253	mov [edx+SRV.bk], eax
278	serge	254
2382	hidnplayr	255	mov ecx, [handler]
		256	mov [eax+SRV.srv_proc], ecx
		257	pop ebx
		258	ret
164	serge	259	.fail:
2382	hidnplayr	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
2382	hidnplayr	268	mov edx, [exp]
164	serge	269	.next:
2382	hidnplayr	270	mov eax, [edx]
		271	test eax, eax
		272	jz .end
164	serge	273
2382	hidnplayr	274	push edx
		275	stdcall strncmp, eax, [sz_name], 16
		276	pop edx
		277	test eax, eax
		278	jz .ok
164	serge	279
2382	hidnplayr	280	add edx, 8
		281	jmp .next
164	serge	282	.ok:
2382	hidnplayr	283	mov eax, [edx+4]
164	serge	284	.end:
2382	hidnplayr	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	@@:
2382	hidnplayr	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:
2382	hidnplayr	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
2382	hidnplayr	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
2382	hidnplayr	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
2382	hidnplayr	325	xor eax, eax
		326	mov ebx, [file_name]
		327	mov ecx, [info]
164	serge	328
2382	hidnplayr	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
2382	hidnplayr	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,\
2382	hidnplayr	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
2382	hidnplayr	356	xor eax, eax
		357	mov ebx, [file_name]
		358	mov ecx, [off]
		359	mov edx, [bytes]
		360	mov esi, [buffer]
164	serge	361
2382	hidnplayr	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
2382	hidnplayr	370	pushad
		371	lea ebx, [cmd]
		372	call file_system_lfn
		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
2382	hidnplayr	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
2382	hidnplayr	404	file dd ?
		405	file2 dd ?
		406	endl
188	serge	407
2382	hidnplayr	408	push esi
		409	push edi
662	serge	410
2382	hidnplayr	411	lea eax, [attr]
		412	stdcall get_fileinfo, [file_name], eax
		413	test eax, eax
		414	jnz .fail
164	serge	415
2382	hidnplayr	416	mov eax, [file_size]
		417	cmp eax, 1024102416
		418	ja .fail
206	serge	419
2382	hidnplayr	420	stdcall kernel_alloc, [file_size]
		421	mov [file], eax
		422	test eax, eax
		423	jz .fail
164	serge	424
2382	hidnplayr	425	stdcall read_file, [file_name], eax, dword 0, [file_size]
		426	cmp ebx, [file_size]
		427	jne .cleanup
211	serge	428
2382	hidnplayr	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
2382	hidnplayr	436	test eax, eax
		437	jz .cleanup
211	serge	438
2382	hidnplayr	439	mov [file2], eax
2540	hidnplayr	440
		441	pushad
		442	mov ecx, unpack_mutex
		443	call mutex_lock
		444	popad
		445
2382	hidnplayr	446	stdcall unpack, [file], eax
2540	hidnplayr	447
		448	pushad
		449	mov ecx, unpack_mutex
		450	call mutex_unlock
		451	popad
		452
2382	hidnplayr	453	stdcall kernel_free, [file]
		454	mov eax, [file2]
		455	mov ebx, [file_size]
211	serge	456	.exit:
2382	hidnplayr	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	@@:
2382	hidnplayr	467	mov ebx, [file_size]
		468	pop eax
		469	pop edi
		470	pop esi
		471	ret
188	serge	472	.cleanup:
2382	hidnplayr	473	stdcall kernel_free, [file]
188	serge	474	.fail:
2382	hidnplayr	475	xor eax, eax
		476	xor ebx, ebx
		477	pop edi
		478	pop esi
		479	ret
188	serge	480	endp
164	serge	481
2540	hidnplayr	482	uglobal
188	serge	483	align 4
2540	hidnplayr	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:
2382	hidnplayr	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:
2382	hidnplayr	498	mov eax, [edx]
		499	test eax, eax
		500	jz .next_table
164	serge	501
2382	hidnplayr	502	push edx
		503	stdcall strncmp, eax, [proc_name], 256
		504	pop edx
		505	test eax, eax
		506	jz .ok
164	serge	507
2382	hidnplayr	508	add edx, 8
		509	jmp .next
188	serge	510	.next_table:
2382	hidnplayr	511	add [imports], 4
		512	jmp .look_up
188	serge	513	.ok:
2382	hidnplayr	514	mov eax, [edx+4]
		515	ret
188	serge	516	.end:
2382	hidnplayr	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,\
2382	hidnplayr	523	sym_count:dword, strings:dword, imports:dword
		524	locals
		525	retval dd ?
		526	endl
164	serge	527
2540	hidnplayr	528	mov edi, [symbols]
		529	mov [retval], 1
		530	.fix:
		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
		537
2382	hidnplayr	538	mov edi, [edi+4]
		539	add edi, [strings]
188	serge	540	@@:
2382	hidnplayr	541	push edi
		542	stdcall get_proc_ex, edi, [imports]
		543	pop edi
164	serge	544
2382	hidnplayr	545	xor ebx, ebx
		546	test eax, eax
		547	jnz @F
164	serge	548
2382	hidnplayr	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
2540	hidnplayr	556	mov [retval], 0
		557	@@:
		558	mov edi, [symbols]
		559	mov [edi+COFF_SYM.Value], eax
		560	jmp .next
		561	.internal:
		562	cmp bx, -1
2382	hidnplayr	563	je .next
		564	cmp bx, -2
		565	je .next
541	serge	566
2382	hidnplayr	567	dec ebx
		568	shl ebx, 3
2540	hidnplayr	569	lea ebx, [ebx+ebx*4]
		570	add ebx, [sec]
		571
		572	mov eax, [ebx+COFF_SECTION.VirtualAddress]
		573	add [edi+COFF_SYM.Value], eax
		574	.next:
		575	add edi, sizeof.COFF_SYM
		576	mov [symbols], edi
		577	dec [sym_count]
		578	jnz .fix
2382	hidnplayr	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, \
2382	hidnplayr	585	delta:dword
		586	locals
		587	n_sec dd ?
2540	hidnplayr	588	endl
		589
		590	mov eax, [coff]
		591	movzx ebx, [eax+COFF_HEADER.nSections]
		592	mov [n_sec], ebx
		593	lea esi, [eax+20]
		594	.fix_sec:
		595	mov edi, [esi+COFF_SECTION.PtrReloc]
		596	add edi, [coff]
		597
		598	movzx ecx, [esi+COFF_SECTION.NumReloc]
		599	test ecx, ecx
		600	jz .next
		601	.reloc_loop:
		602	mov ebx, [edi+COFF_RELOC.SymIndex]
		603	add ebx, ebx
		604	lea ebx, [ebx+ebx*8]
		605	add ebx, [sym]
		606
		607	mov edx, [ebx+COFF_SYM.Value]
		608
		609	cmp [edi+COFF_RELOC.Type], 6
		610	je .dir_32
		611
		612	cmp [edi+COFF_RELOC.Type], 20
		613	jne .next_reloc
		614	.rel_32:
		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
		620	.dir_32:
		621	mov eax, [edi+COFF_RELOC.VirtualAddress]
		622	add eax, [esi+COFF_SECTION.VirtualAddress]
		623	.fix:
		624	add eax, [delta]
		625	add [eax], edx
1289	diamond	626	.next_reloc:
2382	hidnplayr	627	add edi, 10
2540	hidnplayr	628	dec ecx
		629	jnz .reloc_loop
		630	.next:
		631	add esi, sizeof.COFF_SECTION
		632	dec [n_sec]
		633	jnz .fix_sec
		634	.exit:
2382	hidnplayr	635	ret
164	serge	636	endp
		637
2382	hidnplayr	638	align 4
1289	diamond	639	proc rebase_coff stdcall uses ebx esi, coff:dword, sym:dword, \
2382	hidnplayr	640	delta:dword
		641	locals
		642	n_sec dd ?
2540	hidnplayr	643	endl
		644
		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]
		650	.fix_sec:
		651	mov edi, [esi+COFF_SECTION.PtrReloc]
		652	add edi, [coff]
		653
		654	movzx ecx, [esi+COFF_SECTION.NumReloc]
		655	test ecx, ecx
		656	jz .next
		657	.reloc_loop:
		658	cmp [edi+COFF_RELOC.Type], 6
		659	jne .next_reloc
		660	.dir_32:
		661	mov eax, [edi+COFF_RELOC.VirtualAddress]
		662	add eax, [esi+COFF_SECTION.VirtualAddress]
		663	add [eax+edx], edx
		664	.next_reloc:
		665	add edi, 10
		666	dec ecx
		667	jnz .reloc_loop
		668	.next:
		669	add esi, sizeof.COFF_SECTION
		670	dec [n_sec]
		671	jnz .fix_sec
		672	.exit:
2382	hidnplayr	673	ret
1289	diamond	674	endp
		675
188	serge	676	align 4
346	diamond	677	proc load_driver stdcall, driver_name:dword
2382	hidnplayr	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
2382	hidnplayr	686	exports dd ? ;fake exports table
		687	dd ?
		688	file_name rb 13+16+4+1 ; '/sys/drivers/.obj'
		689	endl
188	serge	690
2382	hidnplayr	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:
2382	hidnplayr	698	lea edx, [file_name]
		699	lea edi, [edx+13]
		700	mov ecx, 16
346	diamond	701	@@:
2382	hidnplayr	702	lodsb
		703	test al, al
		704	jz @f
		705	stosb
		706	loop @b
346	diamond	707	@@:
2382	hidnplayr	708	mov dword [edi], '.obj'
		709	mov byte [edi+4], 0
		710	stdcall load_file, edx
214	serge	711
2382	hidnplayr	712	test eax, eax
		713	jz .exit
188	serge	714
2540	hidnplayr	715	mov [coff], eax
		716
		717	movzx ecx, [eax+COFF_HEADER.nSections]
		718	xor ebx, ebx
		719
		720	lea edx, [eax+20]
		721	@@:
		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
		729
2382	hidnplayr	730	stdcall kernel_alloc, ebx
		731	test eax, eax
		732	jz .fail
		733	mov [img_base], eax
188	serge	734
2382	hidnplayr	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
2540	hidnplayr	742	rep stosd
		743
		744	mov edx, [coff]
		745	movzx ebx, [edx+COFF_HEADER.nSections]
		746	mov edi, [img_base]
		747	lea eax, [edx+20]
		748	@@:
		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
		755	.copy:
		756	add esi, edx
		757	mov ecx, [eax+COFF_SECTION.SizeOfRawData]
		758	cld
		759	rep movsb
		760	.next:
		761	add edi, 15
		762	and edi, not 15
		763	add eax, sizeof.COFF_SECTION
		764	dec ebx
		765	jnz @B
		766
		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]
2382	hidnplayr	774	mov [strings], ecx
188	serge	775
2382	hidnplayr	776	lea ebx, [exports]
		777	mov dword [ebx], kernel_export
2540	hidnplayr	778	mov dword [ebx+4], 0
		779	lea eax, [edx+20]
188	serge	780
2540	hidnplayr	781	stdcall fix_coff_symbols, eax, [sym], [edx+COFF_HEADER.nSymbols], \
		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
		789	stdcall get_coff_sym, [sym], [ebx+COFF_HEADER.nSymbols], szVersion
		790	test eax, eax
		791	jz .link_fail
		792
2382	hidnplayr	793	mov eax, [eax]
		794	shr eax, 16
		795	cmp eax, DRV_COMPAT
		796	jb .ver_fail
227	serge	797
2382	hidnplayr	798	cmp eax, DRV_CURRENT
2540	hidnplayr	799	ja .ver_fail
227	serge	800
2540	hidnplayr	801	mov ebx, [coff]
		802	stdcall get_coff_sym, [sym], [ebx+COFF_HEADER.nSymbols], szSTART
		803	mov [start], eax
		804
		805	stdcall kernel_free, [coff]
		806
2382	hidnplayr	807	mov ebx, [start]
		808	stdcall ebx, DRV_ENTRY
		809	test eax, eax
3187	hidnplayr	810	jnz .ok
		811
		812	stdcall kernel_free, [img_base]
		813
		814	xor eax, eax
		815	ret
		816	.ok:
2382	hidnplayr	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:
2382	hidnplayr	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:
2382	hidnplayr	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:
2382	hidnplayr	844	stdcall kernel_free, [img_base]
188	serge	845	.fail:
2382	hidnplayr	846	stdcall kernel_free, [coff]
227	serge	847	.exit:
2382	hidnplayr	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;
2540	hidnplayr	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
		860	mov cl, byte [edx+COFF_SECTION.Characteristics+2]
		861	mov eax, 1
		862	shr cl, 4
		863	dec cl
2382	hidnplayr	864	js .default
		865	cmp cl, 12
		866	jbe @f
1296	diamond	867	.default:
2382	hidnplayr	868	mov cl, 12
1296	diamond	869	@@:
2382	hidnplayr	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
2382	hidnplayr	877	locals
		878	fullname rb 260
		879	fileinfo rb 40
		880	coff dd ?
		881	img_base dd ?
		882	endl
198	serge	883
2382	hidnplayr	884	cli
198	serge	885
1289	diamond	886	; resolve file name
2382	hidnplayr	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
2382	hidnplayr	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:
2382	hidnplayr	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
2382	hidnplayr	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:
2382	hidnplayr	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
2382	hidnplayr	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:
2382	hidnplayr	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:
2382	hidnplayr	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:
2382	hidnplayr	946	mov esi, [esi+DLLDESCR.fd]
		947	jmp .scan_for_dlls
1289	diamond	948
		949	; new DLL
		950	.load_new:
		951	; load file
2382	hidnplayr	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
2382	hidnplayr	959	mov esi, edi
		960	mov ecx, -1
2540	hidnplayr	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
2382	hidnplayr	968	test eax, eax
		969	jz .fail_and_free_coff
1289	diamond	970	; save timestamp
2382	hidnplayr	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
2382	hidnplayr	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
2540	hidnplayr	985
		986	; calculate size of loaded DLL
		987	mov edx, [coff]
		988	movzx ecx, [edx+COFF_HEADER.nSections]
		989	xor ebx, ebx
		990
		991	add edx, 20
198	serge	992	@@:
2382	hidnplayr	993	call coff_get_align
2540	hidnplayr	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
		1001	; it must be nonzero and not too big
2382	hidnplayr	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
2382	hidnplayr	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
2382	hidnplayr	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	@@:
2382	hidnplayr	1022	mov [esi+DLLDESCR.defaultbase], ecx
		1023	mov [dll_cur_addr], edx
198	serge	1024
2540	hidnplayr	1025	; copy sections and set correct values for VirtualAddress'es in headers
		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	@@:
2382	hidnplayr	1033	call coff_get_align
		1034	add ecx, eax
		1035	add edi, eax
2540	hidnplayr	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
2382	hidnplayr	1047	rep stosb
		1048	jmp .next
198	serge	1049	.copy:
2382	hidnplayr	1050	add esi, [coff]
2540	hidnplayr	1051	rep movsb
		1052	.next:
		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
2540	hidnplayr	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]
		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
		1073	@@:
		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
2382	hidnplayr	1088	push esi
		1089	mov esi, edx
		1090	mov edi, eax
		1091	rep movsd
2540	hidnplayr	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
2382	hidnplayr	1099	rep movsb
2540	hidnplayr	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]
		1105	@@:
		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
		1120
		1121	; fixup symbols
		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]
2382	hidnplayr	1127	add ecx, ecx
		1128	add ecx, [esi+DLLDESCR.symbols_ptr]
198	serge	1129
2382	hidnplayr	1130	stdcall fix_coff_symbols, edx, [esi+DLLDESCR.symbols_ptr], eax, \
		1131	ecx, 0
		1132	; test eax, eax
		1133	; jnz @F
2540	hidnplayr	1134	;
		1135	;@@:
		1136
		1137	stdcall get_coff_sym, [esi+DLLDESCR.symbols_ptr], [ebx+COFF_HEADER.nSymbols], szEXPORTS
		1138	test eax, eax
		1139	jnz @F
		1140
		1141	stdcall get_coff_sym, [esi+DLLDESCR.symbols_ptr], [ebx+COFF_HEADER.nSymbols], sz_EXPORTS
		1142	@@:
		1143	mov [esi+DLLDESCR.exports], eax
		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
2382	hidnplayr	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
2382	hidnplayr	1152	stdcall kernel_free, [coff]
916	serge	1153
1289	diamond	1154	.dll_already_loaded:
2382	hidnplayr	1155	inc [esi+DLLDESCR.refcount]
		1156	push esi
		1157	call init_heap
		1158	pop esi
1289	diamond	1159
2382	hidnplayr	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
2540	hidnplayr	1166	jz .fail_and_dereference
		1167	@@:
		1168	mov [img_base], eax
		1169	mov eax, sizeof.HDLL
		1170	call malloc
		1171	test eax, eax
		1172	jz .fail_and_free_user
2382	hidnplayr	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
2382	hidnplayr	1198	xor edi, edi
		1199	mov ecx, [esi+DLLDESCR.data]
		1200	shr ecx, 12
1289	diamond	1201	.map_pages_loop:
2382	hidnplayr	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	@@:
2382	hidnplayr	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
2382	hidnplayr	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
2382	hidnplayr	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:
2382	hidnplayr	1228	stdcall kernel_free, [esi+DLLDESCR.data]
1289	diamond	1229	.fail_and_free_dll:
2382	hidnplayr	1230	mov eax, esi
		1231	call free
1289	diamond	1232	.fail_and_free_coff:
2382	hidnplayr	1233	stdcall kernel_free, [coff]
198	serge	1234	.fail:
2382	hidnplayr	1235	xor eax, eax
		1236	ret
1289	diamond	1237	.fail_and_free_user:
2382	hidnplayr	1238	stdcall user_free, [img_base]
1289	diamond	1239	.fail_and_dereference:
2382	hidnplayr	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:
2382	hidnplayr	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:
2382	hidnplayr	1267	cmp [ebx+APPDATA.dir_table], edx
		1268	jnz @f
		1269	mov [ebx+APPDATA.dlls_list_ptr], eax
1311	diamond	1270	@@:
2382	hidnplayr	1271	add ebx, 256
		1272	dec ecx
		1273	jnz .set
1311	diamond	1274	.ret:
2382	hidnplayr	1275	ret
1311	diamond	1276
1289	diamond	1277	; in: eax = number of references to delete, esi -> DLLDESCR struc
		1278	dereference_dll:
2382	hidnplayr	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:
2382	hidnplayr	1290	ret
1289	diamond	1291
		1292	destroy_hdll:
2382	hidnplayr	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.
2382	hidnplayr	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.
2382	hidnplayr	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:
2382	hidnplayr	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	@@:
2382	hidnplayr	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.
2382	hidnplayr	1341	pop eax
		1342	mov cr3, eax
		1343	pop [current_slot]
		1344	popf
1292	diamond	1345	; Ok, cheating is done.
2382	hidnplayr	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:
2382	hidnplayr	1362	test esi, esi
		1363	jz .ret
1311	diamond	1364	.loop:
2382	hidnplayr	1365	mov eax, [esi+HDLL.fd]
		1366	cmp eax, esi
		1367	jz free
		1368	call destroy_hdll
		1369	jmp .loop
1311	diamond	1370	.ret:
2382	hidnplayr	1371	ret
1311	diamond	1372
214	serge	1373	align 4
1275	serge	1374	stop_all_services:
2540	hidnplayr	1375	push ebp
		1376	mov edx, [srv.fd]
		1377	.next:
		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
		1384
		1385	mov ebx, [edx+SRV.entry]
2382	hidnplayr	1386	mov edx, [edx+SRV.fd]
		1387	test ebx, ebx
		1388	jz .next
732	serge	1389
2382	hidnplayr	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:
2382	hidnplayr	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
2382	hidnplayr	1409	push ebx
		1410	call malloc
		1411	pop ebx
		1412	test eax, eax
		1413	jz .fail
281	serge	1414
2382	hidnplayr	1415	mov ecx, [current_slot]
		1416	add ecx, APP_OBJ_OFFSET
281	serge	1417
2382	hidnplayr	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
2382	hidnplayr	1425	mov [ecx+APPOBJ.fd], eax
		1426	mov [edx+APPOBJ.bk], eax
		1427	popfd
281	serge	1428	.fail:
2382	hidnplayr	1429	ret
281	serge	1430
		1431	; param
		1432	; eax= object
		1433
		1434	align 4
		1435	destroy_kernel_object:
		1436
2382	hidnplayr	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
2382	hidnplayr	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
2382	hidnplayr	1452	call free ;release object memory
		1453	ret

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/core/dll.inc – Rev 3187