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

Rev	Author	Line No.	Line
425	victor	1	$Revision: 431 $
431	serge	2	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
		3	;; ;;
		4	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
		5	;; Distributed under terms of the GNU General Public License ;;
		6	;; ;;
		7	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
164	serge	8
227	serge	9	DRV_ENTRY equ 1
		10	DRV_EXIT equ -1
378	serge	11	DRV_COMPAT equ 4 ;minimal required drivers version
		12	DRV_CURRENT equ 4 ;current drivers model version
214	serge	13
227	serge	14	DRV_VERSION equ (DRV_COMPAT shl 16) or DRV_CURRENT
		15
164	serge	16	align 4
		17	proc attach_int_handler stdcall, irq:dword, handler:dword
		18
		19	mov ebx, [irq] ;irq num
		20	test ebx, ebx
		21	jz .err
		22	mov eax, [handler]
		23	test eax, eax
		24	jz .err
		25	mov [irq_tab+ebx*4], eax
		26	stdcall enable_irq, [irq]
		27	ret
		28	.err:
		29	xor eax, eax
		30	ret
		31	endp
		32
		33	align 4
		34	proc detach_int_handler
		35
		36	ret
		37	endp
		38
		39	align 4
		40	proc enable_irq stdcall, irq_line:dword
		41	mov ebx, [irq_line]
		42	mov edx, 0x21
		43	cmp ebx, 8
		44	jb @F
		45	mov edx, 0xA1
		46	sub ebx,8
		47	@@:
		48	in al,dx
		49	btr eax, ebx
		50	out dx, al
		51	ret
		52	endp
		53
		54	align 16
		55	;; proc irq_serv
		56
		57	irq_serv:
		58
		59	.irq_1:
		60	push eax
		61	mov eax, 1
		62	jmp .main
		63	align 4
		64	.irq_2:
		65	push eax
		66	mov eax, 2
		67	jmp .main
		68	align 4
		69	.irq_3:
		70	push eax
		71	mov eax, 3
		72	jmp .main
		73	align 4
		74	.irq_4:
		75	push eax
		76	mov eax, 4
		77	jmp .main
		78	align 4
		79	.irq_5:
		80	push eax
		81	mov eax, 5
		82	jmp .main
		83	align 4
		84	.irq_6:
		85	push eax
		86	mov eax, 6
		87	jmp .main
		88	align 4
		89	.irq_7:
		90	push eax
		91	mov eax, 7
		92	jmp .main
		93	align 4
		94	.irq_8:
		95	push eax
		96	mov eax, 8
		97	jmp .main
		98	align 4
		99	.irq_9:
		100	push eax
		101	mov eax, 9
		102	jmp .main
		103	align 4
		104	.irq_10:
		105	push eax
		106	mov eax, 10
		107	jmp .main
		108	align 4
		109	.irq_11:
		110	push eax
		111	mov eax, 11
		112	jmp .main
		113	align 4
		114	.irq_12:
		115	push eax
		116	mov eax, 12
		117	jmp .main
		118	align 4
		119	.irq_13:
		120	push eax
		121	mov eax, 13
		122	jmp .main
		123	align 4
		124	.irq_14:
		125	push eax
		126	mov eax, 14
		127	jmp .main
		128	align 4
		129	.irq_15:
		130	push eax
		131	mov eax, 15
		132	jmp .main
		133
		134	align 16
		135	.main:
		136	save_ring3_context
		137	mov bx, os_data
		138	mov ds, bx
		139	mov es, bx
		140
		141	mov ebx, [irq_tab+eax*4]
		142	test ebx, ebx
		143	jz .exit
		144
		145	call ebx
		146
		147	.exit:
		148	restore_ring3_context
		149
		150	cmp eax, 8
		151	mov al, 0x20
		152	jb @f
		153	out 0xa0, al
		154	@@:
		155	out 0x20, al
		156
		157	pop eax
		158	iret
		159
		160	align 4
		161	proc get_notify stdcall, p_ev:dword
		162
		163	.wait:
		164	mov ebx,[CURRENT_TASK]
		165	shl ebx,8
380	serge	166	test dword [ebx+SLOT_BASE+0xA8],EVENT_NOTIFY
164	serge	167	jz @f
380	serge	168	and dword [ebx+SLOT_BASE+0xA8], not EVENT_NOTIFY
164	serge	169	mov edi, [p_ev]
		170	mov dword [edi], EV_INTR
380	serge	171	mov eax, [ebx+SLOT_BASE+APPDATA.event]
164	serge	172	mov dword [edi+4], eax
		173	ret
		174	@@:
		175	call change_task
		176	jmp .wait
		177	endp
		178
		179	align 4
		180	proc pci_read32 stdcall, bus:dword, devfn:dword, reg:dword
		181	xor eax, eax
		182	xor ebx, ebx
		183	mov ah, byte [bus]
		184	mov al, 6
		185	mov bh, byte [devfn]
		186	mov bl, byte [reg]
		187	call pci_read_reg
		188	ret
		189	endp
		190
		191	align 4
		192	proc pci_read8 stdcall, bus:dword, devfn:dword, reg:dword
		193	xor eax, eax
		194	xor ebx, ebx
		195	mov ah, byte [bus]
		196	mov al, 4
		197	mov bh, byte [devfn]
		198	mov bl, byte [reg]
		199	call pci_read_reg
		200	ret
		201	endp
		202
		203	align 4
		204	proc pci_write8 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
		205	xor eax, eax
		206	xor ebx, ebx
		207	mov ah, byte [bus]
		208	mov al, 8
		209	mov bh, byte [devfn]
		210	mov bl, byte [reg]
		211	mov ecx, [val]
		212	call pci_write_reg
		213	ret
		214	endp
		215
		216	handle equ IOCTL.handle
		217	io_code equ IOCTL.io_code
		218	input equ IOCTL.input
		219	inp_size equ IOCTL.inp_size
		220	output equ IOCTL.output
		221	out_size equ IOCTL.out_size
		222
		223
		224	align 4
		225	proc srv_handler stdcall, ioctl:dword
		226	mov esi, [ioctl]
		227	test esi, esi
		228	jz .err
		229
		230	mov edi, [esi+handle]
		231	cmp [edi+SRV.magic], ' SRV'
		232	jne .fail
		233
		234	cmp [edi+SRV.size], SRV_SIZE
		235	jne .fail
		236
		237	stdcall [edi+SRV.srv_proc], esi
		238	ret
		239	.fail:
		240	xor eax, eax
		241	not eax
		242	mov [esi+output], eax
		243	mov [esi+out_size], 4
		244	ret
		245	.err:
		246	xor eax, eax
		247	not eax
		248	ret
		249	endp
		250
377	serge	251	; param
		252	; ebx= io_control
		253	;
		254	; retval
		255	; eax= error code
		256
164	serge	257	align 4
377	serge	258	srv_handlerEx:
		259	test ebx, ebx
		260	jz .fail
		261	add ebx, new_app_base
164	serge	262
377	serge	263	mov eax, [ebx+handle]
		264	cmp [eax+SRV.magic], ' SRV'
164	serge	265	jne .fail
		266
377	serge	267	cmp [eax+SRV.size], SRV_SIZE
164	serge	268	jne .fail
		269
377	serge	270	add [ebx+input], new_app_base
		271	add [ebx+output], new_app_base
164	serge	272
377	serge	273	stdcall [eax+SRV.srv_proc], ebx
164	serge	274	ret
		275	.fail:
377	serge	276	or eax, -1
164	serge	277	ret
		278
		279	restore handle
		280	restore io_code
		281	restore input
		282	restore inp_size
		283	restore output
		284	restore out_size
		285
		286	align 4
		287	proc get_service stdcall, sz_name:dword
188	serge	288	mov eax, [sz_name]
		289	test eax, eax
		290	jnz @F
		291	ret
164	serge	292	@@:
278	serge	293	mov edx, [srv.fd]
188	serge	294	@@:
278	serge	295	cmp edx, srv.fd-SRV_FD_OFFSET
		296	je .not_load
		297
		298	stdcall strncmp, edx, [sz_name], 16
188	serge	299	test eax, eax
		300	je .ok
164	serge	301
278	serge	302	mov edx, [edx+SRV.fd]
		303	jmp @B
164	serge	304	.not_load:
346	diamond	305	pop ebp
		306	jmp load_driver
164	serge	307	.ok:
278	serge	308	mov eax, edx
188	serge	309	ret
164	serge	310	endp
		311
		312	align 4
278	serge	313	reg_service:
		314	.sz_name equ esp+4
		315	.handler equ esp+8
		316	mov eax, [.sz_name]
164	serge	317	test eax, eax
		318	jz .fail
		319
278	serge	320	mov ebx, [.handler]
164	serge	321	test ebx, ebx
		322	jz .fail
		323
278	serge	324	mov eax, SRV_SIZE
		325	call malloc ;call alloc_service
164	serge	326	test eax, eax
		327	jz .fail
		328
		329	mov edi, eax
278	serge	330	mov esi, [.sz_name]
		331	mov ecx, 16/4
		332	rep movsd
164	serge	333
278	serge	334	mov [eax+SRV.magic], ' SRV'
		335	mov [eax+SRV.size], SRV_SIZE
		336
		337	mov ebx, srv.fd-SRV_FD_OFFSET
		338	mov edx, [ebx+SRV.fd]
		339	mov [eax+SRV.fd], edx
		340	mov [eax+SRV.bk], ebx
		341	mov [ebx+SRV.fd], eax
		342	mov [edx+SRV.bk], eax
		343
		344	mov ecx, [.handler]
		345	mov [eax+SRV.srv_proc], ecx
281	serge	346	ret 8
164	serge	347	.fail:
		348	xor eax, eax
281	serge	349	ret 8
164	serge	350
		351	align 4
		352	proc get_proc stdcall, exp:dword, sz_name:dword
		353
		354	mov edx, [exp]
		355	.next:
		356	mov eax, [edx]
		357	test eax, eax
		358	jz .end
		359
		360	push edx
		361	stdcall strncmp, eax, [sz_name], 16
		362	pop edx
		363	test eax, eax
		364	jz .ok
		365
		366	add edx,8
		367	jmp .next
		368	.ok:
		369	mov eax, [edx+4]
		370	.end:
		371	ret
		372	endp
		373
		374	align 4
		375	proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword
		376
		377	@@:
		378	stdcall strncmp, [pSym], [sz_sym], 8
		379	test eax,eax
		380	jz .ok
		381	add [pSym], 18
		382	dec [count]
		383	jnz @b
		384	xor eax, eax
		385	ret
		386	.ok:
		387	mov ebx, [pSym]
		388	mov eax, [ebx+8]
		389	ret
		390	endp
		391
		392	align 4
188	serge	393	proc get_curr_task
		394	mov eax,[CURRENT_TASK]
		395	shl eax, 8
		396	ret
		397	endp
164	serge	398
188	serge	399	align 4
		400	proc get_fileinfo stdcall, file_name:dword, info:dword
		401	locals
		402	cmd dd ?
		403	offset dd ?
		404	dd ?
		405	count dd ?
		406	buff dd ?
		407	db ?
		408	name dd ?
		409	endl
164	serge	410
188	serge	411	xor eax, eax
		412	mov ebx, [file_name]
		413	sub ebx, new_app_base
		414	mov ecx, [info]
		415	sub ecx, new_app_base
164	serge	416
188	serge	417	mov [cmd], 5
		418	mov [offset], eax
		419	mov [offset+4], eax
		420	mov [count], eax
		421	mov [buff], ecx
		422	mov byte [buff+4], al
		423	mov [name], ebx
164	serge	424
188	serge	425	mov eax, 70
		426	lea ebx, [cmd]
		427	sub ebx, new_app_base
		428	int 0x40
		429	ret
		430	endp
164	serge	431
188	serge	432	align 4
		433	proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\
		434	bytes:dword
		435	locals
		436	cmd dd ?
		437	offset dd ?
		438	dd ?
		439	count dd ?
		440	buff dd ?
		441	db ?
		442	name dd ?
		443	endl
164	serge	444
188	serge	445	xor eax, eax
		446	mov ebx, [file_name]
		447	mov ecx, [off]
		448	mov edx, [bytes]
		449	mov esi, [buffer]
		450	sub ebx, new_app_base
		451	sub esi, new_app_base
164	serge	452
188	serge	453	mov [cmd], eax
		454	mov [offset], ecx
		455	mov [offset+4], eax
		456	mov [count], edx
		457	mov [buff], esi
		458	mov byte [buff+4], al
		459	mov [name], ebx
		460
429	serge	461	pushad
		462	push eax
		463	lea eax, [cmd]
		464	sub eax, new_app_base
		465	call file_system_lfn
		466	pop eax
		467	popad
188	serge	468	ret
		469	endp
		470
363	serge	471	; description
		472	; allocate kernel memory and loads the specified file
		473	;
		474	; param
		475	; file_name= full path to file
		476	;
		477	; retval
		478	; eax= file image in kernel memory
		479	; ebx= size of file
		480	;
		481	; warging
		482	; You mast call kernel_free() to delete each file
		483	; loaded by the load_file() function
		484
188	serge	485	align 4
		486	proc load_file stdcall, file_name:dword
		487	locals
		488	attr dd ?
		489	flags dd ?
		490	cr_time dd ?
		491	cr_date dd ?
		492	acc_time dd ?
		493	acc_date dd ?
		494	mod_time dd ?
		495	mod_date dd ?
		496	file_size dd ?
		497
		498	file dd ?
211	serge	499	file2 dd ?
188	serge	500	endl
		501
		502	lea eax, [attr]
		503	stdcall get_fileinfo, [file_name], eax
164	serge	504	test eax, eax
188	serge	505	jnz .fail
164	serge	506
206	serge	507	mov eax, [file_size]
237	serge	508	cmp eax, 1024102416
		509	ja .fail
206	serge	510
188	serge	511	stdcall kernel_alloc, [file_size]
		512	mov [file], eax
164	serge	513
188	serge	514	stdcall read_file, [file_name], eax, dword 0, [file_size]
		515	cmp ebx, [file_size]
		516	jne .cleanup
211	serge	517
188	serge	518	mov eax, [file]
211	serge	519	cmp dword [eax], 0x4B43504B
		520	jne .exit
237	serge	521	mov ebx, [eax+4]
		522	mov [file_size], ebx
		523	stdcall kernel_alloc, ebx
211	serge	524
		525	test eax, eax
		526	jz .cleanup
		527
		528	mov [file2], eax
		529	stdcall unpack, [file], eax
		530	stdcall kernel_free, [file]
		531	mov eax, [file2]
237	serge	532	mov ebx, [file_size]
211	serge	533	.exit:
269	serge	534	push eax
		535	lea edi, [eax+ebx] ;cleanup remain space
357	serge	536	mov ecx, 4096 ;from file end
		537	and ebx, 4095
269	serge	538	sub ecx, ebx
		539	xor eax, eax
		540	cld
		541	rep stosb
357	serge	542	mov ebx, [file_size]
269	serge	543	pop eax
188	serge	544	ret
		545	.cleanup:
		546	stdcall kernel_free, [file]
		547	.fail:
		548	xor eax, eax
237	serge	549	xor ebx, ebx
188	serge	550	ret
		551	endp
164	serge	552
188	serge	553	align 4
		554	proc get_proc_ex stdcall, proc_name:dword, imports:dword
		555
		556	.look_up:
		557	mov edx, [imports]
198	serge	558	test edx, edx
		559	jz .end
188	serge	560	mov edx, [edx]
		561	test edx, edx
		562	jz .end
		563	.next:
		564	mov eax, [edx]
164	serge	565	test eax, eax
188	serge	566	jz .next_table
164	serge	567
188	serge	568	push edx
		569	stdcall strncmp, eax, [proc_name], 16
		570	pop edx
		571	test eax, eax
		572	jz .ok
164	serge	573
188	serge	574	add edx,8
		575	jmp .next
		576	.next_table:
		577	add [imports], 4
		578	jmp .look_up
		579	.ok:
		580	mov eax, [edx+4]
		581	ret
		582	.end:
		583	xor eax, eax
		584	ret
		585	endp
164	serge	586
188	serge	587	align 4
		588	proc fix_coff_symbols stdcall, sec:dword, symbols:dword,\
		589	sym_count:dword, strings:dword, imports:dword
		590	locals
		591	retval dd ?
		592	endl
164	serge	593
188	serge	594	mov edi, [symbols]
		595	mov [retval], 1
		596	.fix:
		597	movzx ebx, [edi+CSYM.SectionNumber]
		598	test ebx, ebx
		599	jnz .internal
		600	mov eax, dword [edi+CSYM.Name]
		601	test eax, eax
		602	jnz @F
164	serge	603
188	serge	604	mov edi, [edi+4]
		605	add edi, [strings]
		606	@@:
		607	push edi
		608	stdcall get_proc_ex, edi,[imports]
		609	pop edi
164	serge	610
188	serge	611	xor ebx, ebx
		612	test eax, eax
		613	jnz @F
164	serge	614
188	serge	615	mov esi, msg_unresolved
		616	call sys_msg_board_str
		617	mov esi, edi
		618	call sys_msg_board_str
		619	mov esi, msg_CR
		620	call sys_msg_board_str
164	serge	621
188	serge	622	mov [retval],0
		623	@@:
		624	mov edi, [symbols]
		625	mov [edi+CSYM.Value], eax
		626	jmp .next
		627	.internal:
		628	dec ebx
		629	shl ebx, 3
		630	lea ebx, [ebx+ebx*4]
		631	add ebx, [sec]
		632
		633	mov eax, [ebx+CFS.VirtualAddress]
		634	add [edi+CSYM.Value], eax
		635	.next:
		636	add edi, CSYM_SIZE
		637	mov [symbols], edi
		638	dec [sym_count]
		639	jnz .fix
		640	mov eax, [retval]
		641	ret
164	serge	642	endp
		643
		644	align 4
188	serge	645	proc fix_coff_relocs stdcall, coff:dword, sec:dword, sym:dword
164	serge	646	locals
188	serge	647	n_sec dd ?
164	serge	648	endl
		649
188	serge	650	mov eax, [coff]
		651	movzx ebx, [eax+CFH.nSections]
		652	mov [n_sec], ebx
		653	.fix_sec:
		654	mov esi, [sec]
164	serge	655	mov edi, [esi+CFS.PtrReloc]
188	serge	656	add edi, [coff]
164	serge	657
188	serge	658	movzx ecx, [esi+CFS.NumReloc]
		659	test ecx, ecx
		660	jz .next
		661	.next_reloc:
164	serge	662	mov ebx, [edi+CRELOC.SymIndex]
		663	add ebx,ebx
		664	lea ebx,[ebx+ebx*8]
188	serge	665	add ebx, [sym]
164	serge	666
188	serge	667	mov edx, [ebx+CSYM.Value]
164	serge	668
188	serge	669	cmp [edi+CRELOC.Type], 6
		670	je .dir_32
164	serge	671
188	serge	672	cmp [edi+CRELOC.Type], 20
		673	jne .next_reloc
		674	.rel_32:
164	serge	675	mov eax, [edi+CRELOC.VirtualAddress]
188	serge	676	add eax, [esi+CFS.VirtualAddress]
		677	sub edx, eax
		678	sub edx, 4
		679	jmp .fix
		680	.dir_32:
		681	mov eax, [edi+CRELOC.VirtualAddress]
		682	add eax, [esi+CFS.VirtualAddress]
		683	.fix:
		684	add [eax], edx
		685	add edi, 10
		686	dec ecx
		687	jnz .next_reloc
		688	.next:
206	serge	689	add [sec], COFF_SECTION_SIZE
188	serge	690	dec [n_sec]
		691	jnz .fix_sec
164	serge	692	.exit:
		693	ret
		694	endp
		695
188	serge	696	align 4
346	diamond	697	proc load_driver stdcall, driver_name:dword
188	serge	698	locals
		699	coff dd ?
		700	sym dd ?
		701	strings dd ?
		702	img_size dd ?
		703	img_base dd ?
		704	start dd ?
		705
		706	exports dd ? ;fake exports table
		707	dd ?
346	diamond	708	file_name rb 14+16+4+1 ; '/rd/1/drivers/.obj'
188	serge	709	endl
		710
346	diamond	711	lea edx, [file_name]
		712	mov dword [edx], '/rd/'
		713	mov dword [edx+4], '1/dr'
		714	mov dword [edx+8], 'iver'
		715	mov word [edx+12], 's/'
		716	mov esi, [driver_name]
		717	lea edi, [edx+14]
		718	mov ecx, 16
		719	@@:
		720	lodsb
		721	test al, al
		722	jz @f
		723	stosb
		724	loop @b
		725	@@:
		726	mov dword [edi], '.obj'
		727	mov byte [edi+4], 0
		728	stdcall load_file, edx
214	serge	729
188	serge	730	test eax, eax
227	serge	731	jz .exit
188	serge	732
		733	mov [coff], eax
		734
		735	movzx ecx, [eax+CFH.nSections]
		736	xor ebx, ebx
		737
		738	lea edx, [eax+20]
		739	@@:
		740	add ebx, [edx+CFS.SizeOfRawData]
		741	add ebx, 15
		742	and ebx, not 15
206	serge	743	add edx, COFF_SECTION_SIZE
188	serge	744	dec ecx
		745	jnz @B
		746	mov [img_size], ebx
		747
		748	stdcall kernel_alloc, ebx
		749	test eax, eax
		750	jz .fail
		751	mov [img_base], eax
		752
		753	mov edi, eax
		754	xor eax, eax
		755	mov ecx, [img_size]
		756	add ecx, 4095
		757	and ecx, not 4095
		758	shr ecx, 2
		759	cld
		760	rep stosd
		761
		762	mov edx, [coff]
		763	movzx ebx, [edx+CFH.nSections]
		764	mov edi, [img_base]
		765	lea eax, [edx+20]
		766	@@:
		767	mov [eax+CFS.VirtualAddress], edi
		768	mov esi, [eax+CFS.PtrRawData]
		769	test esi, esi
		770	jnz .copy
		771	add edi, [eax+CFS.SizeOfRawData]
		772	jmp .next
		773	.copy:
		774	add esi, edx
		775	mov ecx, [eax+CFS.SizeOfRawData]
		776	cld
		777	rep movsb
		778	.next:
		779	add edi, 15
		780	and edi, not 15
206	serge	781	add eax, COFF_SECTION_SIZE
188	serge	782	dec ebx
		783	jnz @B
		784
		785	mov ebx, [edx+CFH.pSymTable]
		786	add ebx, edx
		787	mov [sym], ebx
		788	mov ecx, [edx+CFH.nSymbols]
		789	add ecx,ecx
		790	lea ecx,[ecx+ecx8] ;ecx=18 = nSymbols*CSYM_SIZE
		791	add ecx, [sym]
		792	mov [strings], ecx
		793
		794	lea ebx, [exports]
		795	mov dword [ebx], kernel_export
		796	mov dword [ebx+4], 0
		797	lea eax, [edx+20]
		798
		799	stdcall fix_coff_symbols, eax, [sym], [edx+CFH.nSymbols],\
		800	[strings], ebx
		801	test eax, eax
227	serge	802	jz .link_fail
188	serge	803
		804	mov ebx, [coff]
		805	add ebx, 20
		806	stdcall fix_coff_relocs, [coff], ebx, [sym]
		807
		808	mov ebx, [coff]
227	serge	809	stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szVersion
		810	test eax, eax
		811	jz .link_fail
		812
		813	mov eax, [eax]
		814	shr eax, 16
		815	cmp eax, DRV_COMPAT
		816	jb .ver_fail
		817
		818	cmp eax, DRV_CURRENT
		819	ja .ver_fail
		820
		821	mov ebx, [coff]
188	serge	822	stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szSTART
		823	mov [start], eax
		824
		825	stdcall kernel_free, [coff]
		826
		827	mov ebx, [start]
214	serge	828	stdcall ebx, DRV_ENTRY
188	serge	829	test eax, eax
		830	jnz .ok
		831
		832	stdcall kernel_free, [img_base]
		833	xor eax, eax
		834	ret
		835	.ok:
		836	mov ebx, [img_base]
		837	mov [eax+SRV.base], ebx
214	serge	838	mov ecx, [start]
		839	mov [eax+SRV.entry], ecx
188	serge	840	ret
227	serge	841
		842	.ver_fail:
		843	mov esi, msg_CR
		844	call sys_msg_board_str
346	diamond	845	mov esi, [driver_name]
227	serge	846	call sys_msg_board_str
		847	mov esi, msg_CR
		848	call sys_msg_board_str
		849	mov esi, msg_version
		850	call sys_msg_board_str
		851	mov esi, msg_www
		852	call sys_msg_board_str
		853	jmp .cleanup
		854
		855	.link_fail:
		856	mov esi, msg_module
		857	call sys_msg_board_str
346	diamond	858	mov esi, [driver_name]
227	serge	859	call sys_msg_board_str
		860	mov esi, msg_CR
		861	call sys_msg_board_str
		862	.cleanup:
		863	stdcall kernel_free,[img_base]
188	serge	864	.fail:
227	serge	865	stdcall kernel_free, [coff]
		866	.exit:
188	serge	867	xor eax, eax
		868	ret
164	serge	869	endp
		870
198	serge	871	align 4
		872	proc load_library stdcall, file_name:dword
		873	locals
		874	coff dd ?
		875	sym dd ?
		876	strings dd ?
		877	img_size dd ?
		878	img_base dd ?
		879	exports dd ?
		880	endl
		881
		882	cli
		883
		884	stdcall load_file, [file_name]
		885	test eax, eax
		886	jz .fail
		887
		888	mov [coff], eax
		889	movzx ecx, [eax+CFH.nSections]
		890	xor ebx, ebx
		891
		892	lea edx, [eax+20]
		893	@@:
		894	add ebx, [edx+CFS.SizeOfRawData]
		895	add ebx, 15
		896	and ebx, not 15
206	serge	897	add edx, COFF_SECTION_SIZE
198	serge	898	dec ecx
		899	jnz @B
		900	mov [img_size], ebx
		901
		902	call init_heap
		903	stdcall user_alloc, [img_size]
		904
		905	test eax, eax
		906	jz .fail
		907	mov [img_base], eax
		908
		909	mov edx, [coff]
		910	movzx ebx, [edx+CFH.nSections]
		911	mov edi, [img_base]
		912	lea eax, [edx+20]
		913	@@:
		914	mov [eax+CFS.VirtualAddress], edi
		915	mov esi, [eax+CFS.PtrRawData]
		916	test esi, esi
		917	jnz .copy
		918	add edi, [eax+CFS.SizeOfRawData]
		919	jmp .next
		920	.copy:
		921	add esi, edx
		922	add edi, new_app_base
		923	mov ecx, [eax+CFS.SizeOfRawData]
		924	cld
		925	rep movsb
		926	.next:
		927	add edi, 15-new_app_base
		928	and edi, not 15
206	serge	929	add eax, COFF_SECTION_SIZE
198	serge	930	dec ebx
		931	jnz @B
		932
		933	mov ebx, [edx+CFH.pSymTable]
		934	add ebx, edx
		935	mov [sym], ebx
		936	mov ecx, [edx+CFH.nSymbols]
		937	add ecx,ecx
		938	lea ecx,[ecx+ecx8] ;ecx=18 = nSymbols*CSYM_SIZE
		939	add ecx, [sym]
		940	mov [strings], ecx
		941
		942	lea eax, [edx+20]
		943
		944	stdcall fix_coff_symbols, eax, [sym], [edx+CFH.nSymbols],\
		945	[strings], dword 0
		946	test eax, eax
		947	jnz @F
		948
		949	@@:
		950	mov edx, [coff]
		951	movzx ebx, [edx+CFH.nSections]
		952	mov edi, new_app_base
		953	lea eax, [edx+20]
		954	@@:
		955	add [eax+CFS.VirtualAddress], edi ;patch user space offset
206	serge	956	add eax, COFF_SECTION_SIZE
198	serge	957	dec ebx
		958	jnz @B
		959
		960	add edx, 20
		961	stdcall fix_coff_relocs, [coff], edx, [sym]
		962
		963	mov ebx, [coff]
		964	stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szEXPORTS
		965	mov [exports], eax
		966
		967	stdcall kernel_free, [coff]
		968	mov eax, [exports]
		969	ret
		970	.fail:
		971	xor eax, eax
		972	ret
		973	endp
		974
214	serge	975	align 4
		976	proc stop_all_services
278	serge	977
		978	mov edx, [srv.fd]
214	serge	979	.next:
278	serge	980	cmp edx, srv.fd-SRV_FD_OFFSET
		981	je .done
		982	cmp [edx+SRV.magic], ' SRV'
227	serge	983	jne .next
278	serge	984	cmp [edx+SRV.size], SRV_SIZE
227	serge	985	jne .next
278	serge	986	mov ebx, [edx+SRV.entry]
		987	mov edx, [edx+SRV.fd]
		988	push edx
214	serge	989	stdcall ebx, dword -1
278	serge	990	pop edx
214	serge	991	jmp .next
278	serge	992	.done:
		993	ret
214	serge	994	endp
198	serge	995
281	serge	996	; param
291	serge	997	; eax= size
		998	; ebx= pid
214	serge	999
281	serge	1000	align 4
		1001	create_kernel_object:
		1002
		1003	push ebx
		1004	call malloc
		1005	pop ebx
		1006	test eax, eax
		1007	jz .fail
		1008
		1009	mov ecx,[CURRENT_TASK]
		1010	shl ecx,8
380	serge	1011	add ecx, SLOT_BASE+APP_OBJ_OFFSET
281	serge	1012
345	serge	1013	pushfd
		1014	cli
281	serge	1015	mov edx, [ecx+APPOBJ.fd]
		1016	mov [eax+APPOBJ.fd], edx
		1017	mov [eax+APPOBJ.bk], ecx
		1018	mov [eax+APPOBJ.pid], ebx
		1019
		1020	mov [ecx+APPOBJ.fd], eax
		1021	mov [edx+APPOBJ.bk], eax
345	serge	1022	popfd
281	serge	1023	.fail:
		1024	ret
		1025
		1026	; param
		1027	; eax= object
		1028
		1029	align 4
		1030	destroy_kernel_object:
		1031
345	serge	1032	pushfd
		1033	cli
281	serge	1034	mov ebx, [eax+APPOBJ.fd]
		1035	mov ecx, [eax+APPOBJ.bk]
		1036	mov [ebx+APPOBJ.bk], ecx
		1037	mov [ecx+APPOBJ.fd], ebx
345	serge	1038	popfd
281	serge	1039
		1040	xor edx, edx ;clear common header
		1041	mov [eax], edx
		1042	mov [eax+4], edx
		1043	mov [eax+8], edx
		1044	mov [eax+12], edx
		1045	mov [eax+16], edx
		1046
		1047	call free ;release object memory
		1048	ret
		1049
		1050
346	diamond	1051	;szSound db 'SOUND',0
		1052	;szInfinity db 'INFINITY',0
		1053	szHwMouse db 'ATI2D',0
164	serge	1054
		1055	szSTART db 'START',0
		1056	szEXPORTS db 'EXPORTS',0
		1057	szIMPORTS db 'IMPORTS',0
		1058
188	serge	1059	msg_unresolved db 'unresolved ',0
		1060	msg_module db 'in module ',0
227	serge	1061	msg_version db 'incompatible driver version',13,10,0
		1062	msg_www db 'please visit www.kolibrios.org',13,10,0
188	serge	1063	msg_CR db 13,10,0
		1064
214	serge	1065	align 4
227	serge	1066	create_cursor dd 0
214	serge	1067	set_hw_cursor dd 0
221	serge	1068	hw_restore dd 0

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/dll.inc – Rev 431